apeirogond 0.10.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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

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

use super::*;

#[test]
fn error_response_daemon_failures_maps_safe_categories() {
    // Arrange
    let cases = [
        (
            DaemonError::Layout(a7n_core::layout::LayoutError::Overlap),
            ErrorKind::InvalidLayout,
        ),
        (DaemonError::PairingBusy, ErrorKind::Busy),
        (DaemonError::NotPaired, ErrorKind::NotPaired),
        (
            DaemonError::Pairing(crate::pairing::PairingError::Refused),
            ErrorKind::PairingRefused,
        ),
        (DaemonError::TrustPoisoned, ErrorKind::Internal),
        (
            DaemonError::Pins(crate::pin_store::PinStoreError::BadHex),
            ErrorKind::Internal,
        ),
        (
            DaemonError::Tls(crate::tls::TlsError::Rustls(rustls::Error::General(
                "TLS configuration failed".into(),
            ))),
            ErrorKind::Internal,
        ),
    ];

    for (error, expected) in cases {
        // Act
        let response = error_response(&error);

        // Assert
        let Response::Error { kind, message } = response else {
            panic!("expected an error")
        };
        assert_eq!(kind, expected);
        assert_eq!(
            message,
            if expected == ErrorKind::PairingRefused {
                "pairing refused".into()
            } else {
                error.to_string()
            }
        );
    }
}

#[tokio::test]
async fn dispatch_closed_command_channel_returns_internal() {
    // Arrange
    let (commands, receiver) = mpsc::channel(1);
    drop(receiver);

    // Act
    let response = dispatch(Request::Status, &commands).await;

    // Assert
    assert!(matches!(
        response,
        Response::Error {
            kind: ErrorKind::Internal,
            ..
        }
    ));
}

#[tokio::test]
async fn dispatch_switch_unlinked_peer_returns_not_connected() {
    // Arrange
    let peer = crate::daemon::test_peer::Peer::start();
    let machine = a7n_proto::MachineId::try_from(&[0; a7n_proto::MachineId::LEN][..]).unwrap();

    // Act
    let response = dispatch(Request::Switch { machine }, peer.sender.as_ref().unwrap()).await;

    // Assert
    assert!(matches!(
        response,
        Response::Error {
            kind: ErrorKind::NotConnected,
            ..
        }
    ));
    peer.stop().await;
}

#[tokio::test]
async fn serve_shutdown_flushes_done_and_stops_with_clients_alive() {
    // Arrange
    let peer = crate::daemon::test_peer::Peer::start();
    let sender = peer.sender.as_ref().unwrap().clone();
    let dir = tempfile::tempdir().unwrap();
    let location = a7n_ipc::SocketLocation::new(dir.path().join("private/control.sock"));
    let server = a7n_ipc::IpcServer::bind_at(&location).await.unwrap();
    let task = tokio::spawn(serve(server, sender.clone()));
    let mut client = a7n_ipc::IpcClient::connect_at(&location).await.unwrap();
    let _idle_client = a7n_ipc::IpcClient::connect_at(&location).await.unwrap();

    // Act
    let response = client.request(&Request::Shutdown).await.unwrap();

    // Assert
    assert!(matches!(response, Response::Done));
    tokio::time::timeout(limits::HANDSHAKE_TIMEOUT, task)
        .await
        .unwrap()
        .unwrap();
    assert!(sender.is_closed());
    peer.stop().await;
}