hoard 0.6.1

Hoard backups of files across your filesystem into one location.
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

mod common;

use common::base::{HOARD_ANON_DIR, HOARD_ANON_FILE, HOARD_NAMED};
use common::tester::Tester;

use common::base::DefaultConfigTester;
use hoard::checkers::history::last_paths::{
    Error as LastPathsError, HoardPaths, LastPaths, PilePaths,
};
use hoard::checkers::Error as CheckerError;
use hoard::command::{BackupRestoreError, Command, Error as CommandError};
use hoard::config::Error as ConfigError;
use hoard::paths::SystemPath;

async fn assert_expected_paths(tester: &Tester, expected: &LastPaths) {
    let current = LastPaths::from_default_file()
        .await
        .expect("reading last_paths.json should not fail");
    let anon_file = HOARD_ANON_FILE.parse().unwrap();
    let anon_dir = HOARD_ANON_DIR.parse().unwrap();
    let named = HOARD_NAMED.parse().unwrap();
    assert_eq!(
        current.hoard(&anon_file).expect("hoard should exist").piles,
        expected
            .hoard(&anon_file)
            .expect("hoard should exist")
            .piles,
        "Expected: {:#?}\nReceived{:#?}\n{}",
        expected,
        current,
        tester.extra_logging_output().await
    );
    assert_eq!(
        current.hoard(&anon_dir).expect("hoard should exist").piles,
        expected.hoard(&anon_dir).expect("hoard should exist").piles,
        "Expected: {:#?}\nReceived{:#?}\n{}",
        expected,
        current,
        tester.extra_logging_output().await
    );
    assert_eq!(
        current.hoard(&named).expect("hoard should exist").piles,
        expected.hoard(&named).expect("hoard should exist").piles,
        "Expected: {:#?}\nReceived{:#?}\n{}",
        expected,
        current,
        tester.extra_logging_output().await
    );
}

#[tokio::test]
async fn test_last_paths() {
    let mut tester = DefaultConfigTester::with_log_level(tracing::Level::TRACE).await;

    let timestamp = time::OffsetDateTime::now_utc();
    let first_env_paths = LastPaths::from(maplit::hashmap! {
        HOARD_ANON_FILE.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Anonymous(
                Some(SystemPath::try_from(tester.home_dir().join("first_anon_file")).unwrap())
            )
        },
        HOARD_ANON_DIR.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Anonymous(
                Some(SystemPath::try_from(tester.home_dir().join("first_anon_dir")).unwrap())
            )
        },
        HOARD_NAMED.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Named(
                maplit::hashmap! {
                    "file".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("first_named_file")).unwrap(),
                    "dir1".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("first_named_dir1")).unwrap(),
                    "dir2".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("first_named_dir2")).unwrap()
                }
            )
        }
    });

    let second_env_paths = LastPaths::from(maplit::hashmap! {
        HOARD_ANON_FILE.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Anonymous(
                Some(SystemPath::try_from(tester.home_dir().join("second_anon_file")).unwrap())
            )
        },
        HOARD_ANON_DIR.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Anonymous(
                Some(SystemPath::try_from(tester.home_dir().join("second_anon_dir")).unwrap())
            )
        },
        HOARD_NAMED.parse().unwrap() => HoardPaths {
            timestamp,
            piles: PilePaths::Named(
                maplit::hashmap! {
                    "file".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("second_named_file")).unwrap(),
                    "dir1".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("second_named_dir1")).unwrap(),
                    "dir2".parse().unwrap() =>
                        SystemPath::try_from(tester.home_dir().join("second_named_dir2")).unwrap()
                }
            )
        }
    });

    let backup = Command::Backup { hoards: Vec::new() };
    tester.setup_files().await;

    tester.use_first_env();

    // Running twice should succeed
    tester.expect_command(backup.clone()).await;
    tester.expect_command(backup.clone()).await;
    assert_expected_paths(&tester, &first_env_paths).await;

    // Switching environments (thus paths) should fail
    tester.use_second_env();

    let error = tester
        .run_command(backup.clone())
        .await
        .expect_err("changing environment should have caused last_paths to fail");
    assert!(matches!(
        error,
        ConfigError::Command(CommandError::Backup(BackupRestoreError::Consistency(
            CheckerError::LastPaths(LastPathsError::HoardPathsMismatch)
        )))
    ));
    assert_expected_paths(&tester, &first_env_paths).await;

    // Mismatched paths should not be saved, so first env should succeed still
    tester.use_first_env();

    tester.expect_command(backup.clone()).await;
    assert_expected_paths(&tester, &first_env_paths).await;

    tester.use_second_env();

    tester.expect_forced_command(backup).await;
    assert_expected_paths(&tester, &second_env_paths).await;
}