apeirogond 0.30.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
115
116
117
118

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

use a7n_proto::v1::{Focus, ScrollEvent, ScrollUnit};

use super::*;

async fn driven(daemon: &mut Daemon, peer: MachineId) {
    let actions = daemon.input.focus.on_focus(
        peer,
        &Focus {
            route: 1,
            target: daemon.identity.machine_id.as_bytes().to_vec(),
            ..Default::default()
        },
        true,
        now(),
    );
    daemon.input_actions(actions).await;
}

fn scroll_batch(dx: f32, dy: f32) -> InputBatch {
    InputBatch {
        route: 1,
        motion_seq: 1,
        motion_x: 4,
        motion_y: -4,
        events: vec![InputEvent {
            event: Some(Event::Scroll(ScrollEvent {
                dx,
                dy,
                unit: ScrollUnit::Line.into(),
            })),
        }],
        ..Default::default()
    }
}

#[tokio::test]
async fn receive_input_different_drivers_use_local_peer_speeds_and_reset_remainders() {
    // Arrange
    let (mut daemon, _dir, fake) = daemon(true);
    let mut fake = fake.unwrap();
    let a = MachineId::try_from(&[1; MachineId::LEN][..]).unwrap();
    let b = MachineId::try_from(&[2; MachineId::LEN][..]).unwrap();
    daemon.config.input.speed = 2.0;
    for (peer, pointer, scroll, reverse) in [(a, "0.25", "0.25", "true"), (b, "4", "4", "false")] {
        for (key, value) in [
            ("pointer_speed", pointer),
            ("scroll_speed", scroll),
            ("reverse_scroll", reverse),
        ] {
            daemon
                .config
                .set(&format!("peers.{peer}.{key}"), value)
                .unwrap();
        }
    }
    let mut received = Vec::new();

    // Act
    let unconfigured = MachineId::try_from(&[3; MachineId::LEN][..]).unwrap();
    for peer in [a, b, a, unconfigured] {
        driven(&mut daemon, peer).await;
        daemon.receive_input(peer, &scroll_batch(3.0, -3.0)).await;
        received.push((fake.injected().await, fake.injected().await));
        let actions = daemon.input.focus.on_link_lost(peer);
        daemon.input_actions(actions).await;
    }

    // Assert
    for ((motion, event), (delta, scroll)) in
        received
            .into_iter()
            .zip([(2, 0.0), (32, 12.0), (2, 0.0), (8, 3.0)])
    {
        assert!(matches!(motion, Inject::Motion { dx, dy } if (dx, dy) == (delta, -delta)));
        assert!(
            matches!(event, Inject::Event(InputEvent { event: Some(Event::Scroll(s)) }) if (s.dx, s.dy) == (scroll, -scroll))
        );
    }
}

#[tokio::test]
async fn apply_config_active_driver_updates_scales_and_clamps_global_product() {
    for (base, multiplier, expected) in [(10.0, "4", 400), (0.1, "0.25", 4)] {
        // Arrange
        let (mut daemon, _dir, fake) = daemon(true);
        let mut fake = fake.unwrap();
        let peer = MachineId::try_from(&[1; MachineId::LEN][..]).unwrap();
        driven(&mut daemon, peer).await;
        let mut config = daemon.config.clone();
        config.input.speed = base;
        config
            .set(&format!("peers.{peer}.pointer_speed"), multiplier)
            .unwrap();
        config
            .set(&format!("peers.{peer}.scroll_speed"), "0.5")
            .unwrap();
        config
            .set(&format!("peers.{peer}.reverse_scroll"), "true")
            .unwrap();
        let mut batch = scroll_batch(4.0, -4.0);
        batch.motion_x = 40;
        batch.motion_y = -40;

        // Act
        daemon.apply_config(config).await;
        daemon.receive_input(peer, &batch).await;

        // Assert
        assert!(
            matches!(fake.injected().await, Inject::Motion { dx, dy } if (dx, dy) == (expected, -expected))
        );
        assert!(
            matches!(fake.injected().await, Inject::Event(InputEvent { event: Some(Event::Scroll(s)) }) if (s.dx, s.dy) == (-2.0, 2.0))
        );
    }
}