async-spooled-tempfile 0.1.0

Asynchronous spooled temporary file
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

use std::io::SeekFrom;

use async_spooled_tempfile::{SpooledData, SpooledTempFile};
use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};

#[tokio::test]
async fn test_implicit_rollover() {
    let mut sf = SpooledTempFile::new(5);
    let mut read_buffer = Vec::new();

    assert!(!sf.is_rolled());
    assert!(!sf.is_poisoned());
    assert!(std::matches!(sf.stream_position().await, Ok(0)));
    sf.read_to_end(&mut read_buffer).await.unwrap();
    assert_eq!(read_buffer.len(), 0);

    let first_data_written = b"1234";
    sf.write_all(first_data_written).await.unwrap();

    assert!(!sf.is_rolled());
    assert!(!sf.is_poisoned());
    let res_cur_pos = sf.stream_position().await;
    assert!(std::matches!(res_cur_pos, Ok(4)));
    let cur_pos = res_cur_pos.unwrap();
    sf.seek(SeekFrom::Start(0)).await.unwrap();
    sf.read_to_end(&mut read_buffer).await.unwrap();
    assert_eq!(read_buffer.as_slice(), first_data_written);
    read_buffer.clear();

    sf.seek(SeekFrom::Start(cur_pos)).await.unwrap();

    let second_data_written = b"5678";
    sf.write_all(second_data_written).await.unwrap();

    assert!(sf.is_rolled());
    assert!(!sf.is_poisoned());
    assert!(std::matches!(sf.stream_position().await, Ok(8)));

    sf.seek(SeekFrom::Start(0)).await.unwrap();
    sf.read_to_end(&mut read_buffer).await.unwrap();

    assert_eq!(
        read_buffer,
        [
            first_data_written.as_slice(),
            second_data_written.as_slice()
        ]
        .concat()
    );

    assert!(std::matches!(
        sf.into_inner().await,
        Ok(SpooledData::OnDisk(..))
    ));
}

#[tokio::test]
async fn test_explicit_rollover() {
    let mut sf = SpooledTempFile::new(5);
    let mut read_buffer = Vec::new();

    let first_data_written = b"123";
    sf.write_all(first_data_written).await.unwrap();

    assert!(!sf.is_rolled());
    assert!(!sf.is_poisoned());
    assert!(std::matches!(sf.stream_position().await, Ok(3)));

    sf.seek(SeekFrom::Start(0)).await.unwrap();

    sf.roll().await.unwrap();

    assert!(sf.is_rolled());
    assert!(!sf.is_poisoned());
    assert!(std::matches!(sf.stream_position().await, Ok(0)));

    sf.read_to_end(&mut read_buffer).await.unwrap();
    assert_eq!(read_buffer.as_slice(), first_data_written);
    assert!(std::matches!(
        sf.into_inner().await,
        Ok(SpooledData::OnDisk(..))
    ));
}

#[tokio::test]
async fn test_into_inner() {
    let mut sf1 = SpooledTempFile::new(10);

    let first_data_written = b"1234567";
    sf1.write_all(first_data_written).await.unwrap();

    assert!(!sf1.is_rolled());
    assert!(!sf1.is_poisoned());
    assert!(std::matches!(sf1.stream_position().await, Ok(7)));
    assert!(std::matches!(
        sf1.into_inner().await,
        Ok(SpooledData::InMemory(..))
    ));

    let mut sf2 = SpooledTempFile::with_max_size_and_capacity(10, 10);

    let second_data_written = b"123456789abcdef";
    sf2.write_all(second_data_written).await.unwrap();

    assert!(sf2.is_rolled());
    assert!(!sf2.is_poisoned());
    assert!(std::matches!(sf2.stream_position().await, Ok(15)));
    assert!(std::matches!(
        sf2.into_inner().await,
        Ok(SpooledData::OnDisk(..))
    ));
}

#[tokio::test]
async fn test_set_len() {
    let mut sf1 = SpooledTempFile::new(10);
    sf1.set_len(4).await.unwrap();

    let f1_buffer = match sf1.into_inner().await {
        Ok(SpooledData::InMemory(cur)) => cur.into_inner(),
        _ => panic!("the data of the first spooled file should be in memory"),
    };
    assert_eq!(f1_buffer.as_slice(), b"\x00\x00\x00\x00");

    let mut sf2 = SpooledTempFile::new(5);
    sf2.write_all(b"abc").await.unwrap();
    assert!(!sf2.is_rolled());
    assert!(!sf2.is_poisoned());
    sf2.set_len(10).await.unwrap();

    let mut sf2_file = match sf2.into_inner().await {
        Ok(SpooledData::OnDisk(file)) => file,
        _ => panic!("the data of the second spooled file should be located in a file"),
    };
    sf2_file.seek(SeekFrom::Start(0)).await.unwrap();
    let mut sf2_content = Vec::new();
    sf2_file.read_to_end(&mut sf2_content).await.unwrap();

    assert_eq!(sf2_content.as_slice(), b"abc\x00\x00\x00\x00\x00\x00\x00");
}