zip_archive 1.2.1

Library that archive a directory with a specific compression format.
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

mod common;
extern crate zip_archive;

use std::{path::Path, sync::mpsc::Receiver};

use function_name::named;

use crate::common::{cleanup, get_archiver, setup, Dir};
use zip_archive::Format;

fn assert_receiver<T: AsRef<Path>>(dest: T, receiver: Receiver<String>, format: Format) {
    let mut messages = Vec::new();
    for message in receiver {
        messages.push(message);
    }

    let mut expected_messages = vec![
        "Total archive directory count: 3".to_string(),
        format!(
            "{} archiving complete: {}/dir1{}",
            format.to_string(),
            &dest.as_ref().to_str().unwrap(),
            format.extension()
        ),
        format!(
            "{} archiving complete: {}/dir2{}",
            format.to_string(),
            &dest.as_ref().to_str().unwrap(),
            format.extension()
        ),
        format!(
            "{} archiving complete: {}/dir3{}",
            format.to_string(),
            &dest.as_ref().to_str().unwrap(),
            format.extension()
        ),
        "Archiving Complete!".to_string(),
    ];

    messages.sort();
    expected_messages.sort();

    assert_eq!(messages, expected_messages);
}

fn assert_format<T: AsRef<Path>>(dest: T, format: Format) {
    assert!(dest
        .as_ref()
        .join(format!("dir1{}", format.extension()))
        .is_file());
    assert!(dest
        .as_ref()
        .join(format!("dir2{}", format.extension()))
        .is_file());
    assert!(dest
        .as_ref()
        .join(format!("dir3{}", format.extension()))
        .is_file());
}

#[named]
fn comp_test(format: Format) {
    let Dir {
        origin,
        dest,
        tx,
        tr,
    } = setup(&format!("{}_{}", function_name!(), format.to_string()));

    {
        let archiver = get_archiver(&origin, &dest, tx, format.clone());
        archiver.archive().unwrap();
    }

    assert_receiver(&dest, tr, format.clone());
    assert_format(&dest, format.clone());

    cleanup(&format!("{}_{}", function_name!(), format.to_string()));
}

#[test]
fn comp_test_all() {
    comp_test(Format::_7z);
    comp_test(Format::Xz);
    comp_test(Format::Zip);
}