apeirogond 0.12.0

Daemon for Apeirogon, a cross-platform software KVM
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

// SPDX-License-Identifier: GPL-3.0-or-later

use super::super::receive::check_space;
use super::*;

#[test]
fn check_space_insufficient_bytes_or_margin_refuses_receive() {
    // Arrange
    let directory = std::path::Path::new("receive");

    // Act
    let result = check_space(directory, 1, 0, |path| {
        assert_eq!(path, directory);
        Ok(256 * 1024 * 1024)
    });

    // Assert
    assert_eq!(result, Err(Failure::NoSpace));
}

#[test]
fn check_space_resumed_bytes_requires_only_remainder_and_margin() {
    // Arrange
    let directory = std::path::Path::new("receive");
    let total = 1024 * 1024 * 1024;
    let remainder = 7;

    // Act
    let result = check_space(directory, total, total - remainder, |_| {
        Ok(256 * 1024 * 1024 + remainder)
    });

    // Assert
    assert_eq!(result, Ok(()));
}

#[test]
fn check_space_lookup_failure_allows_receive() {
    // Arrange
    let directory = std::path::Path::new("receive");

    // Act
    let result = check_space(directory, 1, 0, |_| Err(std::io::ErrorKind::Other.into()));

    // Assert
    assert_eq!(result, Ok(()));
}

#[test]
fn check_space_required_bytes_overflow_refuses_receive() {
    // Arrange
    let directory = std::path::Path::new("receive");

    // Act
    let result = check_space(directory, u64::MAX, 0, |_| Ok(u64::MAX));

    // Assert
    assert_eq!(result, Err(Failure::NoSpace));
}

#[tokio::test]
async fn files_finished_no_space_reports_distinct_accept_failure() {
    // Arrange
    let (mut daemon, _dir) = daemon();
    let peer = MachineId::try_from([1; MachineId::LEN].as_slice()).unwrap();
    let (reply, response) = oneshot::channel();
    daemon.files.accepts.insert((peer, 1), reply);
    let (cancel, _) = watch::channel(Failure::Cancelled);
    daemon.files.active.insert(
        1,
        Active {
            peer,
            link: 0,
            wire_id: 1,
            offer: 1,
            kind: Kind::Offer,
            direction: TransferDirection::Receive,
            cancel,
            progress: Arc::new(Progress::default()),
        },
    );

    // Act
    daemon.files_finished(1, Err(Failure::NoSpace));

    // Assert
    let error = response.await.unwrap().unwrap_err();
    assert!(matches!(error, DaemonError::NoSpace));
    assert_eq!(
        error.to_string(),
        "not enough free space in the receive directory"
    );
    assert!(daemon.files.active.is_empty());
    assert!(daemon.files.accepts.is_empty());
}