ElyOffice/apps/ely-mark/src/restore/tests.rs

use crate::view::Mode;

#[test]
fn a_place_without_a_column_or_top_reads_zero() {
    let kept: super::Kept = serde_json::from_str(
        r#"{"path":null,"name":"a.md","mode":"source","place":{"line":3,"scroll":0},"slot":"s"}"#,
    )
    .expect("an older place reads");
    let place = kept.place.expect("a place");
    assert_eq!((place.line, place.column, place.top), (3, 0, 0));
}

#[test]
fn each_untitled_copy_goes_to_the_tab_made_for_it() {
    let dir = tempfile::tempdir().expect("a temp dir");
    let kept = |name: &str, mode: Mode, slot: &str| super::Kept {
        path: None,
        name: name.into(),
        mode,
        place: Some(super::Place {
            line: slot.len() as u64,
            column: 1,
            top: 0,
        }),
        slot: slot.into(),
    };
    let tabs = vec![
        kept("Untitled1", Mode::Visual, "a"),
        kept("Untitled2", Mode::Source, "bb"),
    ];
    for (slot, text) in [("a", "first"), ("bb", "second")] {
        let mut points = super::Recovery::new(super::recovery(dir.path(), slot));
        points
            .write_once(text.as_bytes(), None, std::time::SystemTime::now())
            .expect("a point");
    }
    let saved = serde_json::to_vec(&super::Saved { tabs: tabs.clone() }).expect("a list");
    std::fs::write(dir.path().join("session.json"), saved).expect("the list");
    // A pid no process has: the last run crashed.
    std::fs::write(dir.path().join("session.lock"), "open 4294967295").expect("a lock");
    let (mut keeping, ..) = super::Keeping::start(dir.path()).expect("a session");
    let made: Vec<_> = keeping.untitled();
    assert_eq!(
        made,
        [(0, "Untitled1".to_string()), (1, "Untitled2".to_string())]
    );
    for (at, _) in made {
        keeping.made(at, 10 + at as u64);
    }
    assert!(keeping.take(None, 12).is_none(), "a new tab takes nothing");
    // The second tab shows first: each still takes its own.
    for (id, want, text) in [(11, &tabs[1], "second"), (10, &tabs[0], "first")] {
        let got = keeping.take(None, id).expect("its copy");
        assert_eq!(
            (&got.kept, got.text.map(|(text, _)| text)),
            (want, Some(text.to_string()))
        );
    }
}

#[test]
fn an_unasked_end_keeps_the_lock_and_points_past_release() {
    let dir = tempfile::tempdir().expect("a temp dir");
    let point = dir.path().join("recovery/s/point");
    let (lock, slot) = (
        dir.path().join("session.lock"),
        point.parent().expect("a slot"),
    );
    let (mut held, ..) = super::Keeping::start(dir.path()).expect("a session");
    std::fs::create_dir_all(slot).expect("a slot");
    std::fs::write(&point, "unsaved").expect("a point");
    held.hold();
    held.close();
    assert!(
        lock.exists() && point.exists(),
        "release after quit wiped them"
    );
    drop(held);
    let (mut clean, ..) = super::Keeping::start(dir.path()).expect("a session");
    std::fs::create_dir_all(slot).expect("a slot");
    std::fs::write(&point, "unsaved").expect("a point");
    clean.close();
    assert!(!lock.exists() && !point.exists(), "a clean end clears");
}

mod window {
    use gpui::{Entity, TestAppContext, VisualTestContext};

    use crate::desk::{
        Desk,
        tests::{open, start},
    };
    use crate::view::{MarkView, Mode};

    /// Shows the tab named `name`; its view.
    fn show(desk: &Entity<Desk>, name: &str, cx: &mut VisualTestContext) -> Entity<MarkView> {
        let view = desk.update(cx, |desk, cx| {
            let tab = desk.core.tabs.iter().find(|tab| tab.name.as_ref() == name);
            let tab = tab.unwrap_or_else(|| panic!("no tab {name}"));
            let (id, view) = (tab.id, tab.view.clone());
            desk.core.active = Some(id);
            cx.notify();
            view
        });
        cx.run_until_parked();
        view
    }

    fn names(desk: &Entity<Desk>, cx: &mut VisualTestContext) -> Vec<String> {
        desk.read_with(cx, |desk, _| {
            desk.core
                .tabs
                .iter()
                .map(|tab| tab.name.to_string())
                .collect()
        })
    }

    #[gpui::test]
    fn a_new_launch_brings_back_tabs_modes_places_and_look(
        first: &mut TestAppContext,
        second: &mut TestAppContext,
    ) {
        let (data, files) = (
            tempfile::tempdir().expect("data"),
            tempfile::tempdir().expect("files"),
        );
        let long: String = (0..80).map(|n| format!("Line {n}\n\n")).collect();
        let (a, b) = (files.path().join("a.md"), files.path().join("b.md"));
        std::fs::write(&a, &long).expect("a");
        std::fs::write(&b, "# B\n").expect("b");
        let (desk, cx) = start(first, data.path());
        open(&desk, &a, cx);
        open(&desk, &b, cx);
        let view = show(&desk, "a.md", cx);
        view.update_in(cx, |view, window, cx| {
            view.switch(Mode::Source, window, cx);
            view.document().update(cx, |document, cx| {
                document.set_caret(40, 2, cx);
                document.set_top_line(30, window, cx);
            });
        });
        cx.run_until_parked();
        desk.update(cx, |desk, cx| {
            desk.relook(|look| look.focus = true, cx);
            desk.leave(cx);
            desk.keeping.close();
        });
        cx.run_until_parked();

        let (desk, cx) = start(second, data.path());
        assert_eq!(names(&desk, cx), ["a.md", "b.md"]);
        let view = show(&desk, "a.md", cx);
        let (mode, place) = view.read_with(cx, |view, cx| (view.mode, view.place(cx)));
        assert_eq!(mode, Mode::Source);
        assert_eq!((place.line, place.column, place.top), (40, 2, 30));
        assert!(
            desk.read_with(cx, |desk, _| desk.look.focus),
            "the look came back"
        );
    }

    #[gpui::test]
    fn a_crash_brings_unsaved_text_back_as_a_copy(
        first: &mut TestAppContext,
        second: &mut TestAppContext,
    ) {
        let (data, files) = (
            tempfile::tempdir().expect("data"),
            tempfile::tempdir().expect("files"),
        );
        let a = files.path().join("a.md");
        std::fs::write(&a, "Text.\n").expect("a");
        let (desk, cx) = start(first, data.path());
        open(&desk, &a, cx);
        let view = show(&desk, "a.md", cx);
        view.update(cx, |view, cx| view.adopt("Changed.\n".into(), cx));
        cx.executor()
            .advance_clock(std::time::Duration::from_secs(1));
        cx.run_until_parked();
        desk.update(cx, |desk, cx| desk.keep(cx));
        cx.run_until_parked();
        // A pid no process has: this run crashed.
        std::fs::write(data.path().join("session.lock"), "open 4294967295").expect("a lock");

        let (desk, cx) = start(second, data.path());
        assert_eq!(names(&desk, cx).len(), 2, "{:?}", names(&desk, cx));
        let copy = desk.read_with(cx, |desk, _| {
            let tab = desk
                .core
                .tabs
                .iter()
                .find(|tab| tab.session.path().is_none());
            tab.expect("an untitled copy").name.to_string()
        });
        show(&desk, &copy, cx);
        let (text, dirty) = desk.read_with(cx, |desk, cx| {
            let tab = desk
                .core
                .tabs
                .iter()
                .find(|tab| tab.name.as_ref() == copy)
                .expect("the copy");
            (desk.text_of(tab.id).expect("text"), tab.dirty(cx))
        });
        assert_eq!(text, "Changed.\n");
        assert!(dirty, "the copy is unsaved");
        assert_eq!(
            std::fs::read_to_string(&a).expect("reads"),
            "Text.\n",
            "the file stays"
        );
    }

    #[test]
    fn a_kept_mode_no_build_knows_does_not_read() {
        let read = serde_json::from_str::<super::super::Kept>(
            r#"{"path":null,"name":"a.md","mode":"split","place":null,"slot":"s"}"#,
        );
        assert!(read.is_err(), "an unknown mode is no default");
    }
}