rmux-client 0.1.2

Blocking local client and attach-mode plumbing for the RMUX terminal multiplexer.
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
141
142
143
144
145
146
147
148
149
150

#![cfg(unix)]

mod common;

use std::error::Error;

use common::{session_name, start_server, TestHarness};
use rmux_client::connect;
use rmux_proto::{
    BreakPaneRequest, JoinPaneRequest, NewSessionRequest, NewWindowResponse, PaneTarget, Request,
    Response, SelectPaneResponse, SplitDirection, SplitWindowTarget, TerminalSize, WindowTarget,
};

#[test]
fn pane_transfer_commands_round_trip_through_connection_helpers() -> Result<(), Box<dyn Error>> {
    let harness = TestHarness::new("pane-transfer-helpers");
    let mut server = start_server(&harness)?;
    let mut connection = connect(harness.socket_path())?;
    let session = session_name("alpha");

    assert!(matches!(
        connection.roundtrip(&Request::NewSession(NewSessionRequest {
            session_name: session.clone(),
            detached: true,
            size: Some(TerminalSize {
                cols: 120,
                rows: 40,
            }),
            environment: None,
        }))?,
        Response::NewSession(_)
    ));
    assert_eq!(
        connection.split_window(SplitWindowTarget::Session(session.clone()))?,
        Response::SplitWindow(rmux_proto::SplitWindowResponse {
            pane: PaneTarget::new(session.clone(), 1),
        })
    );
    assert_eq!(
        connection.select_pane(PaneTarget::new(session.clone(), 1))?,
        Response::SelectPane(SelectPaneResponse {
            target: PaneTarget::new(session.clone(), 1),
        })
    );
    assert_eq!(
        connection.select_pane(PaneTarget::new(session.clone(), 0))?,
        Response::SelectPane(SelectPaneResponse {
            target: PaneTarget::new(session.clone(), 0),
        })
    );
    assert_eq!(
        connection.last_pane(WindowTarget::new(session.clone()))?,
        Response::LastPane(rmux_proto::LastPaneResponse {
            target: PaneTarget::new(session.clone(), 1),
        })
    );

    assert_eq!(
        connection.new_window(session.clone(), Some("dest".to_owned()), true)?,
        Response::NewWindow(NewWindowResponse {
            target: WindowTarget::with_window(session.clone(), 1),
        })
    );
    assert_eq!(
        connection.join_pane(JoinPaneRequest {
            source: PaneTarget::new(session.clone(), 1),
            target: PaneTarget::with_window(session.clone(), 1, 0),
            direction: SplitDirection::Vertical,
            detached: true,
            before: false,
            full_size: false,
            size: None,
        })?,
        Response::JoinPane(rmux_proto::JoinPaneResponse {
            target: PaneTarget::with_window(session.clone(), 1, 1),
        })
    );
    assert_eq!(
        connection.break_pane(BreakPaneRequest {
            source: PaneTarget::with_window(session.clone(), 1, 1),
            target: Some(WindowTarget::with_window(session.clone(), 2)),
            name: Some("broken".to_owned()),
            detached: true,
            after: false,
            before: false,
            print_target: false,
            format: None,
        })?,
        Response::BreakPane(rmux_proto::BreakPaneResponse {
            target: PaneTarget::with_window(session.clone(), 2, 0),
            output: None,
        })
    );

    assert!(matches!(
        connection.new_window(session.clone(), Some("swap".to_owned()), true)?,
        Response::NewWindow(_)
    ));
    assert!(matches!(
        connection.split_window(SplitWindowTarget::Pane(PaneTarget::with_window(
            session.clone(),
            3,
            0,
        )))?,
        Response::SplitWindow(_)
    ));
    assert!(matches!(
        connection.kill_pane(PaneTarget::with_window(session.clone(), 3, 0))?,
        Response::KillPane(_)
    ));
    assert_eq!(
        connection.swap_pane(
            PaneTarget::with_window(session.clone(), 2, 0),
            PaneTarget::with_window(session.clone(), 3, 0),
            true,
            false,
        )?,
        Response::SwapPane(rmux_proto::SwapPaneResponse {
            source: PaneTarget::with_window(session.clone(), 2, 0),
            target: PaneTarget::with_window(session.clone(), 3, 0),
        })
    );

    assert!(matches!(
        connection.new_window(session.clone(), Some("relative".to_owned()), true)?,
        Response::NewWindow(_)
    ));
    assert!(matches!(
        connection.split_window(SplitWindowTarget::Pane(PaneTarget::with_window(
            session.clone(),
            4,
            0,
        )))?,
        Response::SplitWindow(_)
    ));
    assert_eq!(
        connection.swap_pane_with_previous(
            PaneTarget::with_window(session.clone(), 4, 1),
            true,
            false,
        )?,
        Response::SwapPane(rmux_proto::SwapPaneResponse {
            source: PaneTarget::with_window(session.clone(), 4, 0),
            target: PaneTarget::with_window(session.clone(), 4, 1),
        })
    );

    server.shutdown()?;
    Ok(())
}