//! Full backup/restore scenario against a DISPOSABLE fixture (never point this at a real server). use coa_core::backup::{self, Kind, Trigger}; use std::path::Path; fn main() { let root = std::env::args().nth(1).expect("usage: backup_e2e "); assert!(root.to_lowercase().contains("fixture"), "refusing: not a fixture folder"); let root = Path::new(&root); let meta = coa_core::registry::metadata_dir_for(root).unwrap(); std::fs::create_dir_all(&meta).unwrap(); let t = std::time::Instant::now(); let point = backup::create(root, &meta, Kind::Quick, Trigger::Manual, Some("e2e".into()), &|s| println!(" .. {s}")).expect("backup"); println!("quick backup {} in {:?}: {:?}", point.id, t.elapsed(), point.components.iter().map(|c| (&c.name, c.bytes, c.tables)).collect::>()); assert!(backup::verify(&meta, &point.id).unwrap().ok); // Change live state after the backup. backup::with_database(root, |db| { db.query("CREATE TABLE acore_characters.manager_marker (id INT); INSERT INTO acore_characters.manager_marker VALUES (42);")?; assert_eq!(db.query("SELECT COUNT(*) FROM acore_characters.manager_marker;")?, "1"); Ok(()) }) .unwrap(); let r = backup::restore_database(root, &meta, &point.id, "characters").expect("restore"); println!("restored {} tables; previous database kept as {}; safety backup {}", r.tables_restored, r.previous_schema, r.safety_backup); backup::with_database(root, |db| { let live = db.tables("acore_characters")?; assert!(!live.contains(&"manager_marker".to_string()), "marker must be gone from the restored database"); let old = db.tables(&r.previous_schema)?; assert!(old.contains(&"manager_marker".to_string()), "the replaced database keeps the marker"); assert_eq!(db.query(&format!("SELECT id FROM {}.manager_marker;", r.previous_schema))?, "42"); assert_eq!(live.len(), r.tables_restored); println!("OK: live tables {}, old schema tables {}", live.len(), old.len()); Ok(()) }) .unwrap(); // A rejected restore (server "running" is simulated by a damaged backup) must change nothing. let victim = meta.join("backups").join(&point.id).join("characters.sql.zst"); let mut bytes = std::fs::read(&victim).unwrap(); bytes[10] ^= 0xFF; std::fs::write(&victim, bytes).unwrap(); assert!(backup::verify(&meta, &point.id).unwrap().problems.len() == 1); assert!(backup::restore_database(root, &meta, &point.id, "characters").is_err()); println!("damaged backup correctly refused"); }