666 строк · 33 КиБ
code/crates/chl-core/src/state.rs
| 1 | //! Состояние запусков: что и когда игра использовала в прошлый раз. |
| 2 | //! |
| 3 | //! Нужно ровно для одного: заметить, что условия запуска изменились, и |
| 4 | //! сделать снимок префикса **до** того, как изменение будет применено. |
| 5 | //! Смена сборки Wine или применение патча реестра — самые частые способы |
| 6 | //! сломать работавшую игру, и «откатиться» без снимка означает собирать |
| 7 | //! префикс заново. |
| 8 | //! |
| 9 | //! Лежит в каталоге состояния, а не данных: потеря этого файла ничем не |
| 10 | //! грозит — в худшем случае лаунчер сделает лишний снимок. |
| 11 | |
| 12 | use std::collections::BTreeMap; |
| 13 | use std::path::Path; |
| 14 | |
| 15 | use anyhow::Result; |
| 16 | use serde::{Deserialize, Serialize}; |
| 17 | |
| 18 | /// Что игра использовала в прошлый запуск. |
| 19 | /// Сессия короче минуты — это не игра, а падение на старте или проверка: |
| 20 | /// в среднюю сессию она не входит. |
| 21 | pub const MIN_SESSION_SECS: u64 = 60; |
| 22 | |
| 23 | #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)] |
| 24 | pub struct GameState { |
| 25 | /// Сборка Wine прошлого запуска. |
| 26 | #[serde(default)] |
| 27 | pub wine: String, |
| 28 | /// Префикс прошлого запуска. |
| 29 | #[serde(default)] |
| 30 | pub prefix: String, |
| 31 | /// Когда запускали в последний раз — секунды эпохи Unix. |
| 32 | #[serde(default)] |
| 33 | pub last_run: u64, |
| 34 | /// Сколько раз запускали. Полезно, чтобы не снимать снимок на самом |
| 35 | /// первом запуске: там ещё нечего терять. |
| 36 | #[serde(default)] |
| 37 | pub runs: u64, |
| 38 | /// Сколько всего наиграно, в секундах. |
| 39 | /// |
| 40 | /// Считается по времени жизни процесса игры. Для игр, которые запускает |
| 41 | /// внешний лончер и сразу отдают управление, число будет заниженным — но |
| 42 | /// «примерно столько» полезнее, чем ничего. |
| 43 | #[serde(default)] |
| 44 | pub played_secs: u64, |
| 45 | /// Сколько длился **последний** сеанс, в секундах. |
| 46 | /// |
| 47 | /// Не то же, что [`Self::played_secs`]: там сумма за всё время, здесь — |
| 48 | /// одна последняя сессия. Нужно ряду «Продолжить» в шапке библиотеки: |
| 49 | /// на вопрос «во что я вчера играл и сколько просидел» отвечает именно |
| 50 | /// длина последнего сеанса, а общий налёт за год — нет. |
| 51 | /// |
| 52 | /// Ноль у игры с непустым `runs` — законное состояние, а не пропажа |
| 53 | /// данных: так выглядят и запуски до появления этого поля, и игры, |
| 54 | /// которые запускает внешний лончер и сразу отдаёт управление (там |
| 55 | /// процесс живёт секунды). Показывать в таком случае нечего, и подпись |
| 56 | /// это учитывает. |
| 57 | #[serde(default)] |
| 58 | pub last_session_secs: u64, |
| 59 | /// Сессии не короче [`MIN_SESSION_SECS`]: сколько их и сколько они |
| 60 | /// длились вместе. Из них считается «средняя сессия» на странице |
| 61 | /// статистики. По всем запускам среднее выходило «12 с»: его тянули вниз |
| 62 | /// мгновенные выходы — падения на старте, проверки и отладка. |
| 63 | #[serde(default)] |
| 64 | pub long_runs: u64, |
| 65 | #[serde(default)] |
| 66 | pub long_secs: u64, |
| 67 | /// Отпечаток последнего применённого патча реестра: имя и содержимое. |
| 68 | /// |
| 69 | /// Именно содержимое, а не только имя: патч правят руками, и «тот же |
| 70 | /// файл» после правки — уже другой патч. Пустая строка означает, что |
| 71 | /// патч не задан. |
| 72 | #[serde(default)] |
| 73 | pub registry_patch: String, |
| 74 | /// Сколько запусков с HDR подряд кончились в первую минуту — так |
| 75 | /// «HDR сам» узнаёт, что HDR с этой игрой не работает (см. |
| 76 | /// `chl_wine::hdr::verdict_from_runs`). Долгий сеанс с HDR обнуляет. |
| 77 | #[serde(default)] |
| 78 | pub hdr_short_runs: u32, |
| 79 | } |
| 80 | |
| 81 | /// Состояние всех игр. |
| 82 | #[derive(Debug, Clone, Default, Serialize, Deserialize)] |
| 83 | pub struct State { |
| 84 | #[serde(default)] |
| 85 | pub games: BTreeMap<String, GameState>, |
| 86 | } |
| 87 | |
| 88 | impl State { |
| 89 | pub fn load(path: &Path) -> Self { |
| 90 | std::fs::read_to_string(path) |
| 91 | .ok() |
| 92 | .and_then(|t| toml::from_str(&t).ok()) |
| 93 | .unwrap_or_default() |
| 94 | } |
| 95 | |
| 96 | pub fn save(&self, path: &Path) -> Result<()> { |
| 97 | let text = toml::to_string_pretty(self)?; |
| 98 | crate::paths::write_atomically(path, &text) |
| 99 | } |
| 100 | |
| 101 | pub fn get(&self, game: &str) -> Option<&GameState> { |
| 102 | self.games.get(game) |
| 103 | } |
| 104 | |
| 105 | /// Переносит наигранное и статистику под новое имя — переименование в |
| 106 | /// библиотеке ([`crate::library::Library::rename`]) не должно обнулять |
| 107 | /// историю игры. Без записи под старым именем — тихий no-op: нечего |
| 108 | /// переносить, и это не ошибка. |
| 109 | pub fn rename(&mut self, old: &str, new: &str) { |
| 110 | if old == new { |
| 111 | return; |
| 112 | } |
| 113 | if let Some(entry) = self.games.remove(old) { |
| 114 | self.games.insert(new.to_string(), entry); |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | /// Сливает историю одной записи в другую и убирает исходную. |
| 119 | /// |
| 120 | /// Нужно при слиянии дубликатов ([`crate::repair::apply_dedupe`]): две |
| 121 | /// записи, оказавшиеся одной игрой, наиграны одним человеком, и часы |
| 122 | /// поэтому складываются, а не выбираются — выбрать значило бы стереть |
| 123 | /// часть настоящей истории. «Последний запуск» — самый поздний из двух; |
| 124 | /// сборка Wine и префикс берутся у той записи, что остаётся, а от |
| 125 | /// исходной — только если у остающейся их не было. |
| 126 | pub fn merge_into(&mut self, from: &str, into: &str) { |
| 127 | if from == into { |
| 128 | return; |
| 129 | } |
| 130 | let Some(gone) = self.games.remove(from) else { |
| 131 | return; |
| 132 | }; |
| 133 | let entry = self.games.entry(into.to_string()).or_default(); |
| 134 | entry.played_secs += gone.played_secs; |
| 135 | entry.runs += gone.runs; |
| 136 | entry.last_run = entry.last_run.max(gone.last_run); |
| 137 | if entry.wine.is_empty() { |
| 138 | entry.wine = gone.wine; |
| 139 | } |
| 140 | if entry.prefix.is_empty() { |
| 141 | entry.prefix = gone.prefix; |
| 142 | } |
| 143 | if entry.registry_patch.is_empty() { |
| 144 | entry.registry_patch = gone.registry_patch; |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | /// Добавляет время, проведённое в игре, и запоминает длину этого сеанса. |
| 149 | /// |
| 150 | /// Зовётся ровно один раз за запуск — после выхода из игры (см. |
| 151 | /// `chl-cli`), поэтому `secs` и есть длина последнего сеанса, а не |
| 152 | /// слагаемое посреди него. |
| 153 | pub fn add_playtime(&mut self, game: &str, secs: u64) { |
| 154 | if let Some(entry) = self.games.get_mut(game) { |
| 155 | entry.played_secs += secs; |
| 156 | entry.last_session_secs = secs; |
| 157 | if secs >= MIN_SESSION_SECS { |
| 158 | entry.long_runs += 1; |
| 159 | entry.long_secs += secs; |
| 160 | } |
| 161 | } |
| 162 | } |
| 163 | |
| 164 | /// Итог запуска с HDR: короткий сеанс копится, долгий обнуляет счёт. |
| 165 | pub fn note_hdr_run(&mut self, game: &str, secs: u64) { |
| 166 | if let Some(entry) = self.games.get_mut(game) { |
| 167 | entry.hdr_short_runs = |
| 168 | if secs < MIN_SESSION_SECS { entry.hdr_short_runs.saturating_add(1) } else { 0 }; |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | /// Отмечает запуск, который сделали не мы: игру запускает Steam, а |
| 173 | /// лаунчер только просит его об этом. |
| 174 | /// |
| 175 | /// Сборку Wine и префикс не трогает намеренно: их выбирает Proton, и |
| 176 | /// записать сюда свои значения значило бы соврать логике снимков — |
| 177 | /// она сравнивает эти поля, чтобы поймать смену сборки. |
| 178 | /// |
| 179 | /// Один старт такой игры проходит через две точки: команду |
| 180 | /// `steam://rungameid` и слой совместимости, который Steam вызывает |
| 181 | /// уже сам. Обе зовут этот метод, поэтому повторный вызов в пределах |
| 182 | /// [`EXTERNAL_LAUNCH_WINDOW`] считается тем же самым запуском — иначе |
| 183 | /// счётчик рос бы вдвое. Цена — потерянный запуск у того, кто закрыл |
| 184 | /// игру и тут же открыл заново; «последний запуск» при этом всё равно |
| 185 | /// обновляется, а ряд «Продолжить» смотрит именно на него. |
| 186 | pub fn record_external(&mut self, game: &str) { |
| 187 | let now = unix_now(); |
| 188 | let entry = self.games.entry(game.to_string()).or_default(); |
| 189 | if entry.last_run == 0 || now.saturating_sub(entry.last_run) > EXTERNAL_LAUNCH_WINDOW { |
| 190 | entry.runs += 1; |
| 191 | } |
| 192 | entry.last_run = now; |
| 193 | } |
| 194 | |
| 195 | /// Записывает состояние после успешного запуска. |
| 196 | pub fn record(&mut self, game: &str, wine: &str, prefix: &str, registry_patch: &str) { |
| 197 | let entry = self.games.entry(game.to_string()).or_default(); |
| 198 | entry.wine = wine.to_string(); |
| 199 | entry.prefix = prefix.to_string(); |
| 200 | entry.registry_patch = registry_patch.to_string(); |
| 201 | entry.runs += 1; |
| 202 | entry.last_run = unix_now(); |
| 203 | } |
| 204 | } |
| 205 | |
| 206 | /// Окно, внутри которого два сообщения о внешнем запуске считаются одним. |
| 207 | /// |
| 208 | /// Три минуты — с запасом на то, что между командой Steam и настоящим |
| 209 | /// стартом игры он успевает докачать обновление или показать свой лончер. |
| 210 | const EXTERNAL_LAUNCH_WINDOW: u64 = 180; |
| 211 | |
| 212 | fn unix_now() -> u64 { |
| 213 | std::time::SystemTime::now() |
| 214 | .duration_since(std::time::UNIX_EPOCH) |
| 215 | .map(|d| d.as_secs()) |
| 216 | .unwrap_or(0) |
| 217 | } |
| 218 | |
| 219 | /// Причина, по которой стоит снять снимок перед запуском. |
| 220 | #[derive(Debug, Clone, PartialEq, Eq)] |
| 221 | pub enum SnapshotReason { |
| 222 | /// Сборка Wine отличается от прошлого запуска. |
| 223 | WineChanged { from: String, to: String }, |
| 224 | /// Патч реестра появился или изменился с прошлого запуска. |
| 225 | /// |
| 226 | /// Патч правит реестр префикса необратимо: откатить его, не имея |
| 227 | /// снимка, можно только пересборкой префикса. |
| 228 | RegistryPatch { name: String }, |
| 229 | /// Запускается winetricks: ставит и убирает библиотеки и шрифты прямо в |
| 230 | /// префиксе, часто необратимо (сам winetricks истории изменений не |
| 231 | /// ведёт). |
| 232 | Winetricks, |
| 233 | /// Открывается служебный инструмент Wine, который правит префикс |
| 234 | /// вручную: winecfg (в том числе вкладка Libraries — ручные |
| 235 | /// DLL-оверрайды, в отличие от настройки `dll_overrides`, которая живёт |
| 236 | /// только в переменной окружения и префикс не трогает), regedit, |
| 237 | /// uninstaller, cmd. |
| 238 | PrefixTool { tool: String }, |
| 239 | } |
| 240 | |
| 241 | impl SnapshotReason { |
| 242 | /// Метка снимка. |
| 243 | pub fn label(&self) -> String { |
| 244 | match self { |
| 245 | SnapshotReason::WineChanged { from, .. } => format!("до смены Wine с {from}"), |
| 246 | SnapshotReason::RegistryPatch { name } => format!("до патча реестра {name}"), |
| 247 | SnapshotReason::Winetricks => "до winetricks".to_string(), |
| 248 | SnapshotReason::PrefixTool { tool } => format!("до {tool}"), |
| 249 | } |
| 250 | } |
| 251 | |
| 252 | /// Объяснение для человека. |
| 253 | pub fn explain(&self) -> String { |
| 254 | match self { |
| 255 | SnapshotReason::WineChanged { from, to } => format!( |
| 256 | "сборка Wine меняется с {from} на {to} — делаю снимок префикса, \ |
| 257 | чтобы можно было вернуться" |
| 258 | ), |
| 259 | SnapshotReason::RegistryPatch { name } => format!( |
| 260 | "патч реестра {name} новый или изменился с прошлого запуска — \ |
| 261 | делаю снимок префикса, чтобы можно было вернуться" |
| 262 | ), |
| 263 | SnapshotReason::Winetricks => "запускается winetricks — он ставит и убирает \ |
| 264 | библиотеки прямо в префиксе, часто необратимо — делаю снимок \ |
| 265 | префикса, чтобы можно было вернуться" |
| 266 | .to_string(), |
| 267 | SnapshotReason::PrefixTool { tool } => format!( |
| 268 | "открывается {tool} — он умеет менять префикс вручную — делаю \ |
| 269 | снимок префикса, чтобы можно было вернуться" |
| 270 | ), |
| 271 | } |
| 272 | } |
| 273 | } |
| 274 | |
| 275 | /// Начала меток, которые лончер ставит снимкам сам. |
| 276 | /// |
| 277 | /// Список ровно тот, что рождает [`SnapshotReason::label`] — второй копии |
| 278 | /// правды нет, и тест `все_метки_автоснимков_узнаются` это сторожит. Нужен |
| 279 | /// он уборке снимков: она удаляет только автоматические, а снятый человеком |
| 280 | /// не трогает никогда. Метки снимков, снятых до появления поля `origin` в |
| 281 | /// `.chl-snapshot`, узнаются только так, по началу строки, поэтому здесь |
| 282 | /// перечислены целые начала («до смены Wine с »), а не одно слово «до»: |
| 283 | /// ручной снимок с меткой «до поездки» под правило попадать не должен. |
| 284 | pub const AUTOMATIC_LABEL_PREFIXES: &[&str] = &[ |
| 285 | "до смены Wine с ", |
| 286 | "до патча реестра ", |
| 287 | "до winetricks", |
| 288 | "до winecfg", |
| 289 | "до regedit", |
| 290 | "до uninstaller", |
| 291 | "до cmd", |
| 292 | // `chl deps --install`: без этой строки снимок считался ручным и не |
| 293 | // убирался политикой хранения никогда. |
| 294 | "до установки пакетов", |
| 295 | "автобэкап сохранений", |
| 296 | ]; |
| 297 | |
| 298 | /// Похожа ли метка на ту, что лончер ставит сам. |
| 299 | pub fn is_automatic_label(label: &str) -> bool { |
| 300 | AUTOMATIC_LABEL_PREFIXES.iter().any(|p| label.starts_with(p)) |
| 301 | } |
| 302 | |
| 303 | /// Нужен ли снимок перед тем, как открыть служебный инструмент Wine в |
| 304 | /// префиксе (`chl tool …`, кнопки «Инструменты префикса» на странице игры). |
| 305 | /// |
| 306 | /// В отличие от [`snapshot_needed`], здесь не с чем сравнить «было — стало»: |
| 307 | /// такие инструменты открывают не на каждом запуске игры, а по явному |
| 308 | /// действию человека, и снимок делается каждый раз, когда инструмент |
| 309 | /// способен поменять префикс — открытие не настолько частое действие, чтобы |
| 310 | /// экономить на нём снимками. |
| 311 | /// |
| 312 | /// `explorer` намеренно не входит: это просто файловый менеджер, открытый на |
| 313 | /// каталоге префикса — тот же риск, что и уже существующая кнопка «Открыть |
| 314 | /// префикс» на странице игры, перед которой снимок никогда не делался. |
| 315 | pub fn snapshot_before_tool(tool: &str) -> Option<SnapshotReason> { |
| 316 | match tool { |
| 317 | "winetricks" => Some(SnapshotReason::Winetricks), |
| 318 | "winecfg" | "regedit" | "uninstaller" | "cmd" => { |
| 319 | Some(SnapshotReason::PrefixTool { tool: tool.to_string() }) |
| 320 | } |
| 321 | _ => None, |
| 322 | } |
| 323 | } |
| 324 | |
| 325 | /// Нужен ли снимок перед этим запуском. |
| 326 | /// |
| 327 | /// Снимок делается **только при изменении условий** и только если игра уже |
| 328 | /// запускалась: на первом запуске терять нечего, а снимать префикс при |
| 329 | /// каждом старте значило бы засорять диск и раздражать. |
| 330 | pub fn snapshot_needed( |
| 331 | state: Option<&GameState>, |
| 332 | wine: &str, |
| 333 | prefix: &str, |
| 334 | registry_patch: &str, |
| 335 | ) -> Option<SnapshotReason> { |
| 336 | let prev = state?; |
| 337 | if prev.runs == 0 { |
| 338 | return None; |
| 339 | } |
| 340 | // Префикс другой — это другая «установка Windows», и снимать текущую |
| 341 | // незачем: изменение её не коснётся. |
| 342 | if prev.prefix != prefix { |
| 343 | return None; |
| 344 | } |
| 345 | if !prev.wine.is_empty() && prev.wine != wine { |
| 346 | return Some(SnapshotReason::WineChanged { |
| 347 | from: prev.wine.clone(), |
| 348 | to: wine.to_string(), |
| 349 | }); |
| 350 | } |
| 351 | // Патч реестра правит префикс необратимо. Снимаем, когда он появился |
| 352 | // или изменился, а не при каждом запуске: применение того же патча |
| 353 | // второй раз ничего нового не делает. |
| 354 | if !registry_patch.is_empty() && prev.registry_patch != registry_patch { |
| 355 | return Some(SnapshotReason::RegistryPatch { |
| 356 | name: patch_name(registry_patch), |
| 357 | }); |
| 358 | } |
| 359 | None |
| 360 | } |
| 361 | |
| 362 | /// Отпечаток патча реестра: имя файла и содержимое. |
| 363 | /// |
| 364 | /// Содержимое учитывается, потому что патч правят руками, и «тот же файл» |
| 365 | /// после правки — уже другой патч, который стоит снять до применения. |
| 366 | pub fn patch_fingerprint(name: &str, path: &std::path::Path) -> String { |
| 367 | let Ok(bytes) = std::fs::read(path) else { |
| 368 | return String::new(); |
| 369 | }; |
| 370 | // FNV-1a: нам нужна не криптостойкость, а «изменилось или нет». |
| 371 | let mut hash: u64 = 0xcbf2_9ce4_8422_2325; |
| 372 | for b in &bytes { |
| 373 | hash ^= u64::from(*b); |
| 374 | hash = hash.wrapping_mul(0x1000_0000_01b3); |
| 375 | } |
| 376 | format!("{name}:{hash:016x}") |
| 377 | } |
| 378 | |
| 379 | fn patch_name(fingerprint: &str) -> String { |
| 380 | fingerprint |
| 381 | .rsplit_once(':') |
| 382 | .map_or_else(|| fingerprint.to_string(), |(name, _)| name.to_string()) |
| 383 | } |
| 384 | |
| 385 | #[cfg(test)] |
| 386 | mod tests { |
| 387 | #[test] |
| 388 | fn средняя_сессия_без_мгновенных_выходов() { |
| 389 | let mut st = State::default(); |
| 390 | st.record("G", "w", "p", ""); |
| 391 | st.add_playtime("G", 3); |
| 392 | st.record("G", "w", "p", ""); |
| 393 | st.add_playtime("G", 600); |
| 394 | st.record("G", "w", "p", ""); |
| 395 | st.add_playtime("G", 1200); |
| 396 | let g = st.get("G").unwrap(); |
| 397 | assert_eq!((g.runs, g.played_secs), (3, 1803)); |
| 398 | assert_eq!((g.long_runs, g.long_secs), (2, 1800)); |
| 399 | } |
| 400 | |
| 401 | use super::*; |
| 402 | |
| 403 | fn state(wine: &str, prefix: &str, runs: u64) -> GameState { |
| 404 | GameState { |
| 405 | wine: wine.into(), |
| 406 | prefix: prefix.into(), |
| 407 | runs, |
| 408 | last_run: 0, |
| 409 | played_secs: 0, |
| 410 | last_session_secs: 0, |
| 411 | long_runs: 0, |
| 412 | long_secs: 0, |
| 413 | registry_patch: String::new(), |
| 414 | hdr_short_runs: 0, |
| 415 | } |
| 416 | } |
| 417 | |
| 418 | #[test] |
| 419 | fn переименование_переносит_историю_под_новое_имя() { |
| 420 | let mut st = State::default(); |
| 421 | st.games.insert("Старое".to_string(), state("wine-11", "pfx_default", 5)); |
| 422 | st.rename("Старое", "Новое"); |
| 423 | assert!(st.get("Старое").is_none()); |
| 424 | assert_eq!(st.get("Новое").unwrap().runs, 5); |
| 425 | } |
| 426 | |
| 427 | #[test] |
| 428 | fn переименование_без_записи_ничего_не_делает() { |
| 429 | let mut st = State::default(); |
| 430 | st.rename("Нет-такой", "Тоже-нет"); |
| 431 | assert!(st.games.is_empty()); |
| 432 | } |
| 433 | |
| 434 | #[test] |
| 435 | fn на_первом_запуске_снимок_не_нужен() { |
| 436 | assert_eq!(snapshot_needed(None, "wine-11", "pfx_default", ""), None); |
| 437 | let s = state("", "pfx_default", 0); |
| 438 | assert_eq!(snapshot_needed(Some(&s), "wine-11", "pfx_default", ""), None); |
| 439 | } |
| 440 | |
| 441 | #[test] |
| 442 | fn без_изменений_снимок_не_нужен() { |
| 443 | let s = state("wine-11", "pfx_default", 5); |
| 444 | assert_eq!(snapshot_needed(Some(&s), "wine-11", "pfx_default", ""), None); |
| 445 | } |
| 446 | |
| 447 | #[test] |
| 448 | fn смена_сборки_wine_требует_снимка() { |
| 449 | let s = state("wine-11", "pfx_default", 5); |
| 450 | let reason = snapshot_needed(Some(&s), "GE-Proton10-34", "pfx_default", "").unwrap(); |
| 451 | assert!(reason.label().contains("wine-11")); |
| 452 | assert!(reason.explain().contains("GE-Proton10-34")); |
| 453 | } |
| 454 | |
| 455 | #[test] |
| 456 | fn другой_префикс_не_повод_снимать_текущий() { |
| 457 | // Изменение не коснётся префикса, снимок которого мы бы сделали. |
| 458 | let s = state("wine-11", "pfx_default", 5); |
| 459 | assert_eq!(snapshot_needed(Some(&s), "GE-Proton10-34", "pfx_игра", ""), None); |
| 460 | } |
| 461 | |
| 462 | #[test] |
| 463 | fn наигранное_время_копится() { |
| 464 | let mut s = State::default(); |
| 465 | s.record("Игра", "wine-11", "pfx_default", ""); |
| 466 | s.add_playtime("Игра", 600); |
| 467 | s.record("Игра", "wine-11", "pfx_default", ""); |
| 468 | s.add_playtime("Игра", 300); |
| 469 | assert_eq!(s.get("Игра").unwrap().played_secs, 900); |
| 470 | // Общий налёт копится, а длина последнего сеанса — заменяется: |
| 471 | // ряд «Продолжить» показывает «сколько играл в прошлый раз», а не |
| 472 | // сумму за всё время. |
| 473 | assert_eq!(s.get("Игра").unwrap().last_session_secs, 300); |
| 474 | // Незнакомой игре время не приписываем. |
| 475 | s.add_playtime("Другая", 100); |
| 476 | assert!(s.get("Другая").is_none()); |
| 477 | } |
| 478 | |
| 479 | #[test] |
| 480 | fn длина_сеанса_читается_из_старого_файла_как_ноль() { |
| 481 | // Поле появилось позже самого runs.toml: у записей, сделанных до |
| 482 | // него, его в файле нет — это ноль, а не отказ читать файл. |
| 483 | let old = "[games.\"Игра\"]\nlast_run = 100\nruns = 3\nplayed_secs = 7200\n"; |
| 484 | let st: State = toml::from_str(old).unwrap(); |
| 485 | let g = st.get("Игра").unwrap(); |
| 486 | assert_eq!(g.played_secs, 7200); |
| 487 | assert_eq!(g.last_session_secs, 0); |
| 488 | } |
| 489 | |
| 490 | #[test] |
| 491 | fn запись_и_чтение() { |
| 492 | let d = std::env::temp_dir().join("chl-test-state"); |
| 493 | std::fs::remove_dir_all(&d).ok(); |
| 494 | let p = d.join("state.toml"); |
| 495 | |
| 496 | let mut s = State::default(); |
| 497 | s.record("Игра", "wine-11", "pfx_default", ""); |
| 498 | s.record("Игра", "wine-11", "pfx_default", ""); |
| 499 | s.save(&p).unwrap(); |
| 500 | |
| 501 | let back = State::load(&p); |
| 502 | let g = back.get("Игра").unwrap(); |
| 503 | assert_eq!(g.runs, 2); |
| 504 | assert_eq!(g.wine, "wine-11"); |
| 505 | assert!(g.last_run > 0); |
| 506 | std::fs::remove_dir_all(&d).ok(); |
| 507 | } |
| 508 | |
| 509 | #[test] |
| 510 | fn новый_патч_реестра_требует_снимка() { |
| 511 | // Патч правит реестр префикса необратимо: без снимка откатить его |
| 512 | // можно только пересборкой префикса. |
| 513 | let s = state("wine-11", "pfx_default", 5); |
| 514 | let reason = |
| 515 | snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:abc").unwrap(); |
| 516 | assert!(reason.label().contains("fix.reg"), "{}", reason.label()); |
| 517 | assert!(!reason.explain().contains("abc"), "хеш человеку не нужен"); |
| 518 | } |
| 519 | |
| 520 | #[test] |
| 521 | fn тот_же_патч_второй_раз_снимка_не_требует() { |
| 522 | let mut s = state("wine-11", "pfx_default", 5); |
| 523 | s.registry_patch = "fix.reg:abc".into(); |
| 524 | assert_eq!( |
| 525 | snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:abc"), |
| 526 | None |
| 527 | ); |
| 528 | // А правка того же файла — уже другой патч. |
| 529 | assert!( |
| 530 | snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:xyz").is_some(), |
| 531 | "изменённый патч должен снова требовать снимка" |
| 532 | ); |
| 533 | } |
| 534 | |
| 535 | #[test] |
| 536 | fn отпечаток_меняется_вместе_с_файлом() { |
| 537 | let d = std::env::temp_dir().join("chl-test-patch-fp"); |
| 538 | std::fs::create_dir_all(&d).unwrap(); |
| 539 | let p = d.join("fix.reg"); |
| 540 | std::fs::write(&p, "первое").unwrap(); |
| 541 | let a = patch_fingerprint("fix.reg", &p); |
| 542 | std::fs::write(&p, "второе").unwrap(); |
| 543 | let b = patch_fingerprint("fix.reg", &p); |
| 544 | assert_ne!(a, b, "правка файла должна менять отпечаток"); |
| 545 | assert!(a.starts_with("fix.reg:")); |
| 546 | assert!(patch_fingerprint("нет", &d.join("нет")).is_empty()); |
| 547 | std::fs::remove_dir_all(&d).ok(); |
| 548 | } |
| 549 | |
| 550 | #[test] |
| 551 | fn winetricks_и_редакторы_реестра_требуют_снимка() { |
| 552 | for tool in ["winetricks", "winecfg", "regedit", "uninstaller", "cmd"] { |
| 553 | assert!( |
| 554 | snapshot_before_tool(tool).is_some(), |
| 555 | "{tool} должен требовать снимка" |
| 556 | ); |
| 557 | } |
| 558 | } |
| 559 | |
| 560 | #[test] |
| 561 | fn explorer_снимка_не_требует() { |
| 562 | // Файловый менеджер на префиксе — не опаснее уже существующей |
| 563 | // кнопки «Открыть префикс», перед которой снимок никогда не делался. |
| 564 | assert_eq!(snapshot_before_tool("explorer"), None); |
| 565 | assert_eq!(snapshot_before_tool("неизвестный-инструмент"), None); |
| 566 | } |
| 567 | |
| 568 | #[test] |
| 569 | fn причины_для_инструментов_объяснены_человеку() { |
| 570 | let reason = snapshot_before_tool("winetricks").unwrap(); |
| 571 | assert_eq!(reason.label(), "до winetricks"); |
| 572 | assert!(reason.explain().contains("winetricks")); |
| 573 | |
| 574 | let reason = snapshot_before_tool("regedit").unwrap(); |
| 575 | assert_eq!(reason.label(), "до regedit"); |
| 576 | assert!(reason.explain().contains("regedit")); |
| 577 | } |
| 578 | |
| 579 | #[test] |
| 580 | fn все_метки_автоснимков_узнаются() { |
| 581 | // Уборка снимков решает по метке, автоматический снимок перед ней |
| 582 | // или снятый человеком. Разойдись этот список с `label()` — уборка |
| 583 | // перестанет видеть свои же снимки и накопит их снова. |
| 584 | let reasons = [ |
| 585 | SnapshotReason::WineChanged { from: "wine-11".into(), to: "GE-Proton10-34".into() }, |
| 586 | SnapshotReason::RegistryPatch { name: "ags.reg".into() }, |
| 587 | SnapshotReason::Winetricks, |
| 588 | SnapshotReason::PrefixTool { tool: "winecfg".into() }, |
| 589 | SnapshotReason::PrefixTool { tool: "regedit".into() }, |
| 590 | SnapshotReason::PrefixTool { tool: "uninstaller".into() }, |
| 591 | SnapshotReason::PrefixTool { tool: "cmd".into() }, |
| 592 | ]; |
| 593 | for reason in reasons { |
| 594 | let label = reason.label(); |
| 595 | assert!(is_automatic_label(&label), "метка {label:?} должна узнаваться"); |
| 596 | } |
| 597 | } |
| 598 | |
| 599 | #[test] |
| 600 | fn ручные_метки_за_автоматические_не_принимаются() { |
| 601 | assert!(!is_automatic_label("вручную")); |
| 602 | assert!(!is_automatic_label("бэкап")); |
| 603 | // Начало «до » само по себе ничего не значит: человек тоже вправе |
| 604 | // назвать снимок «до чего-то». |
| 605 | assert!(!is_automatic_label("до поездки")); |
| 606 | assert!(!is_automatic_label("до установки мода")); |
| 607 | } |
| 608 | |
| 609 | #[test] |
| 610 | fn запуск_через_steam_попадает_в_последние() { |
| 611 | // Без этой записи игра из Steam никогда не появлялась в ряду |
| 612 | // «Продолжить»: он строится по `last_run`, а его ставил только наш |
| 613 | // собственный запуск. |
| 614 | let mut st = State::default(); |
| 615 | st.record_external("Helldivers 2"); |
| 616 | let entry = st.get("Helldivers 2").unwrap(); |
| 617 | assert_eq!(entry.runs, 1); |
| 618 | assert!(entry.last_run > 0); |
| 619 | // Сборку Wine и префикс выбирает Proton — врать о них нельзя. |
| 620 | assert!(entry.wine.is_empty()); |
| 621 | assert!(entry.prefix.is_empty()); |
| 622 | } |
| 623 | |
| 624 | #[test] |
| 625 | fn один_старт_через_две_точки_считается_одним_запуском() { |
| 626 | // Команда `steam://rungameid` и слой совместимости сообщают об |
| 627 | // одном и том же старте. Считать их за два — завысить статистику |
| 628 | // ровно вдвое у всех игр Steam. |
| 629 | let mut st = State::default(); |
| 630 | st.record_external("Helldivers 2"); |
| 631 | st.record_external("Helldivers 2"); |
| 632 | assert_eq!(st.get("Helldivers 2").unwrap().runs, 1); |
| 633 | } |
| 634 | |
| 635 | #[test] |
| 636 | fn старый_запуск_окно_не_склеивает() { |
| 637 | let mut st = State::default(); |
| 638 | st.record_external("Helldivers 2"); |
| 639 | // Сеанс закончился давно — следующий старт обязан считаться новым. |
| 640 | st.games.get_mut("Helldivers 2").unwrap().last_run -= EXTERNAL_LAUNCH_WINDOW + 1; |
| 641 | st.record_external("Helldivers 2"); |
| 642 | assert_eq!(st.get("Helldivers 2").unwrap().runs, 2); |
| 643 | } |
| 644 | |
| 645 | #[test] |
| 646 | fn битый_файл_не_ломает_запуск() { |
| 647 | let d = std::env::temp_dir().join("chl-test-state2"); |
| 648 | std::fs::create_dir_all(&d).unwrap(); |
| 649 | let p = d.join("state.toml"); |
| 650 | std::fs::write(&p, "не toml {{{").unwrap(); |
| 651 | assert!(State::load(&p).games.is_empty()); |
| 652 | std::fs::remove_dir_all(&d).ok(); |
| 653 | } |
| 654 | |
| 655 | #[test] |
| 656 | fn короткие_запуски_с_hdr_копятся_долгий_обнуляет() { |
| 657 | let mut st = State::default(); |
| 658 | st.record("Игра", "w", "p", ""); |
| 659 | st.note_hdr_run("Игра", 10); |
| 660 | st.note_hdr_run("Игра", 20); |
| 661 | assert_eq!(st.get("Игра").unwrap().hdr_short_runs, 2); |
| 662 | st.note_hdr_run("Игра", MIN_SESSION_SECS + 1); |
| 663 | assert_eq!(st.get("Игра").unwrap().hdr_short_runs, 0); |
| 664 | } |
| 665 | } |
| 666 |