wsb 0.275.7622

Workspace tools for every project under $PRJ: git across submodules, template stamping, GitHub, and the workbench
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use super::*;
use crate::test_environment::Environment;

/// TEST20107: a worktree's local state is filed under `$PRJ/.state` by its
/// workspace and worktree name, and named in the workshop's database the same
/// way; a checkout outside the workshop under this machine's folder by its
/// resolved path; and a folder that is in a workspace but in no worktree has
/// none.
///
/// Nothing a worktree keeps for itself may land in the worktree: its `.wsb/`
/// is committed whole. Two checkouts outside the workshop must never share a
/// folder, and one checkout must always find the same one, however its path
/// is spelled.
#[test]
fn test20107_local_state_is_filed_by_place_and_never_in_the_checkout() {
    let prj = tempfile::tempdir().expect("a workshop");
    let machine = tempfile::tempdir().expect("a machine folder");
    let elsewhere = tempfile::tempdir().expect("a folder outside the workshop");
    for folder in ["alpha/main-worktree", "alpha/fix-worktree", "alpha/notes"] {
        std::fs::create_dir_all(prj.path().join(folder)).unwrap();
    }
    let outside_first = elsewhere.path().join("first");
    let outside_second = elsewhere.path().join("second");
    std::fs::create_dir_all(&outside_first).unwrap();
    std::fs::create_dir_all(&outside_second).unwrap();
    let workshop = crate::platform::canonicalize(prj.path()).unwrap();
    let machine_dir = machine.path().to_string_lossy().into_owned();
    let mut env = Environment::set(&[
        ("PRJ", &workshop.to_string_lossy()),
        (crate::daemon::MACHINE_DIR_ENV, &machine_dir),
    ]);

    let fix = LocalState::of(&workshop.join("alpha/fix-worktree")).expect("a worktree's state");
    assert_eq!(fix.dir(), workshop.join(".state/workspaces/alpha/worktrees/fix"));
    assert_eq!(fix.key(), "alpha/fix");
    assert_eq!(
        LocalState::of(&workshop.join("alpha/main-worktree")).unwrap().dir(),
        workshop.join(".state/workspaces/alpha/worktrees/main")
    );

    let loose = LocalState::of(&workshop.join("alpha/notes")).expect_err("a folder that is no worktree");
    assert!(loose.to_string().contains("none of its worktrees"), "{loose}");

    let first = LocalState::of(&outside_first).expect("an outside checkout's state");
    assert_eq!(first.dir().parent(), Some(machine.path().join("outside").as_path()));
    assert_eq!(first.key(), format!("outside/{}", first.dir().file_name().unwrap().to_string_lossy()));
    assert_ne!(first, LocalState::of(&outside_second).unwrap(), "two checkouts share one folder");
    #[cfg(unix)]
    {
        let link = elsewhere.path().join("link");
        std::os::unix::fs::symlink(&outside_first, &link).unwrap();
        assert_eq!(LocalState::of(&link).unwrap(), first, "a symlinked spelling found other state");
    }

    // No workshop at all: everything is outside one.
    env.unset("PRJ");
    let without = LocalState::of(&workshop.join("alpha/fix-worktree")).expect("state with no $PRJ");
    assert!(without.dir().starts_with(machine.path().join("outside")), "{}", without.dir().display());
}