zesty-backup 1.0.2

A flexible, multi-provider backup utility for cloud storage
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

// Backup functionality integration tests

use std::fs;
use std::path::PathBuf;
use tempfile::TempDir;

/// Test backup file naming
#[test]
fn test_backup_file_naming() {
    use chrono::Local;

    let timestamp = Local::now().format("%Y%m%d-%H%M%S");
    let full_backup = format!("backup-full-{}.tar.zst", timestamp);
    let incr_backup = format!("backup-incr-{}.tar.zst", timestamp);

    assert!(full_backup.starts_with("backup-full-"));
    assert!(full_backup.ends_with(".tar.zst"));
    assert!(incr_backup.starts_with("backup-incr-"));
    assert!(incr_backup.ends_with(".tar.zst"));
}

/// Test backup directory structure creation
#[test]
fn test_backup_directory_creation() {
    let temp_dir = TempDir::new().unwrap();
    let backup_dir = temp_dir.path().join("backups");

    fs::create_dir_all(&backup_dir).unwrap();
    assert!(backup_dir.exists());

    // Create a test backup file
    let backup_file = backup_dir.join("test-backup.tar.zst");
    fs::write(&backup_file, b"test backup content").unwrap();
    assert!(backup_file.exists());
}

/// Test compression level validation
#[test]
fn test_compression_level_validation() {
    let valid_levels = vec![0, 3, 6, 9, 12, 15, 18, 22];
    let invalid_levels = vec![-1, 23, 100];

    for level in valid_levels {
        assert!(level >= 0 && level <= 22, "Level {} should be valid", level);
    }

    for level in invalid_levels {
        assert!(level < 0 || level > 22, "Level {} should be invalid", level);
    }
}

/// Test retention policy calculation
#[test]
fn test_retention_policy() {
    use chrono::{Duration, Utc};

    let retention_days = 7;
    let cutoff_date = Utc::now() - Duration::days(retention_days);

    // Simulate backup dates
    let old_backup_date = Utc::now() - Duration::days(10);
    let new_backup_date = Utc::now() - Duration::days(3);

    assert!(
        old_backup_date < cutoff_date,
        "Old backup should be deleted"
    );
    assert!(new_backup_date > cutoff_date, "New backup should be kept");
}

/// Test path exclusion logic
#[test]
fn test_path_exclusion() {
    let exclude_patterns = vec!["node_modules", "*.log", ".git"];
    let test_paths = vec![
        ("/project/node_modules/package", true),
        ("/project/src/main.rs", false),
        ("/project/app.log", true),
        ("/project/.git/config", true),
        ("/project/data.txt", false),
    ];

    for (path, should_exclude) in test_paths {
        let excluded = exclude_patterns.iter().any(|pattern| {
            if pattern.starts_with("*.") {
                path.ends_with(&pattern[1..])
            } else {
                path.contains(pattern)
            }
        });

        assert_eq!(
            excluded, should_exclude,
            "Path {} exclusion check failed",
            path
        );
    }
}

/// Test backup file size calculation
#[test]
fn test_backup_file_size() {
    let temp_dir = TempDir::new().unwrap();
    let test_file = temp_dir.path().join("test.txt");
    let content = "This is test content for backup size calculation";

    fs::write(&test_file, content).unwrap();
    let metadata = fs::metadata(&test_file).unwrap();

    assert!(metadata.len() > 0);
    assert_eq!(metadata.len(), content.len() as u64);
}

/// Test timestamp parsing for backup files
#[test]
fn test_backup_timestamp_parsing() {
    use chrono::NaiveDateTime;

    let backup_name = "backup-full-20240101-120000.tar.zst";
    let timestamp_str = backup_name
        .strip_prefix("backup-full-")
        .unwrap()
        .strip_suffix(".tar.zst")
        .unwrap();

    let parsed = NaiveDateTime::parse_from_str(timestamp_str, "%Y%m%d-%H%M%S");
    assert!(parsed.is_ok());

    let dt = parsed.unwrap();
    assert_eq!(dt.format("%Y%m%d-%H%M%S").to_string(), timestamp_str);
}