aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorAram Drevekenin <aram@poor.dev>2021-11-12 17:22:14 +0100
committerGitHub <noreply@github.com>2021-11-12 17:22:14 +0100
commitbd795a3e9f0f9cc6c36ac250b29d6df13a265526 (patch)
treece9d6606578daf1fd26688269a12c54120992463 /src
parentdoc(changelog): CSI cursor next line fix (diff)
downloadsl0ppij-bd795a3e9f0f9cc6c36ac250b29d6df13a265526.tar.gz
sl0ppij-bd795a3e9f0f9cc6c36ac250b29d6df13a265526.tar.xz
sl0ppij-bd795a3e9f0f9cc6c36ac250b29d6df13a265526.zip
refactor(tabs): lay down infrastructure for multiple users (#864)
* refactor(screen): support multiple mirrored clients * style(fmt): make rustfmt happy * style(clippy): make clippy happy * whitespace * github, y u no update CI?! * is this a cache issue? * is it the checkout cache? * no cache at all? * Debug * fix gototab * decoment * gototab none in wasm_vm * gototab none in wasm_vm * the fun never ends * tests(e2e): update infra and add multiple user mirroring test * refactor(tab): change structs in tabs and terminal panes to support multiple users * style(fmt): make rustfmt happy * style(fmt): make clippy happy
Diffstat (limited to 'src')
-rw-r--r--src/tests/e2e/cases.rs1458
-rw-r--r--src/tests/e2e/remote_runner.rs412
-rw-r--r--src/tests/e2e/snapshots/zellij__tests__e2e__cases__cannot_split_terminals_vertically_when_active_terminal_is_too_small.snap2
-rw-r--r--src/tests/e2e/snapshots/zellij__tests__e2e__cases__close_tab.snap50
-rw-r--r--src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions-2.snap29
-rw-r--r--src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions.snap8
-rw-r--r--src/tests/e2e/snapshots/zellij__tests__e2e__cases__typing_exit_closes_pane.snap29
7 files changed, 1240 insertions, 748 deletions
diff --git a/src/tests/e2e/cases.rs b/src/tests/e2e/cases.rs
index aa8ad34b..0198adfe 100644
--- a/src/tests/e2e/cases.rs
+++ b/src/tests/e2e/cases.rs
@@ -75,8 +75,12 @@ pub fn starts_with_one_terminal() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("starts_with_one_terminal", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size);
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for app to load",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -86,8 +90,13 @@ pub fn starts_with_one_terminal() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -99,8 +108,11 @@ pub fn split_terminals_vertically() {
rows: 24,
};
- let last_snapshot = RemoteRunner::new("split_terminals_vertically", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size).add_step(Step {
name: "Split pane to the right",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -114,8 +126,9 @@ pub fn split_terminals_vertically() {
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for new pane to appear",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -125,8 +138,14 @@ pub fn split_terminals_vertically() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -134,49 +153,11 @@ pub fn split_terminals_vertically() {
#[ignore]
pub fn cannot_split_terminals_vertically_when_active_terminal_is_too_small() {
let fake_win_size = Size { cols: 8, rows: 20 };
- let last_snapshot = RemoteRunner::new(
- "cannot_split_terminals_vertically_when_active_terminal_is_too_small",
- fake_win_size,
- )
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2) {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Make sure only one pane appears",
- instruction: |remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(3, 2) && remote_terminal.snapshot_contains("...")
- {
- // ... is the truncated tip line
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .run_all_steps();
- assert_snapshot!(last_snapshot);
-}
-
-#[test]
-#[ignore]
-pub fn scrolling_inside_a_pane() {
- let fake_win_size = Size {
- cols: 120,
- rows: 24,
- };
- let last_snapshot = RemoteRunner::new("scrolling_inside_a_pane", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size).add_step(Step {
name: "Split pane to the right",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -190,52 +171,109 @@ pub fn scrolling_inside_a_pane() {
}
step_is_complete
},
- })
- .add_step(Step {
- name: "Fill terminal with text",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(format!("{:0<56}", "line1 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line2 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line3 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line4 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line5 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line6 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line7 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line8 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line9 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line10 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line11 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line12 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line13 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line14 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line15 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line16 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line17 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line18 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line19 ").as_bytes());
- remote_terminal.send_key(format!("{:0<57}", "line20 ").as_bytes());
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Scroll up inside pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
+ name: "Make sure only one pane appears",
+ instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(118, 20) {
- // all lines have been written to the pane
- remote_terminal.send_key(&SCROLL_MODE);
- remote_terminal.send_key(&SCROLL_UP_IN_SCROLL_MODE);
+ // if remote_terminal.cursor_position_is(3, 2) && remote_terminal.snapshot_contains("...")
+ if remote_terminal.cursor_position_is(3, 2) {
+ // ... is the truncated tip line
step_is_complete = true;
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
+ assert_snapshot!(last_snapshot);
+}
+
+#[test]
+#[ignore]
+pub fn scrolling_inside_a_pane() {
+ let fake_win_size = Size {
+ cols: 120,
+ rows: 24,
+ };
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .retry_pause_ms(1000) // we need a longer retry period here because it takes some time to fill the pty buffer
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Fill terminal with text",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ let mut content_to_send = String::new();
+ content_to_send.push_str(&format!("{:0<56}", "line1 "));
+ content_to_send.push_str(&format!("{:0<58}", "line2 "));
+ content_to_send.push_str(&format!("{:0<58}", "line3 "));
+ content_to_send.push_str(&format!("{:0<58}", "line4 "));
+ content_to_send.push_str(&format!("{:0<58}", "line5 "));
+ content_to_send.push_str(&format!("{:0<58}", "line6 "));
+ content_to_send.push_str(&format!("{:0<58}", "line7 "));
+ content_to_send.push_str(&format!("{:0<58}", "line8 "));
+ content_to_send.push_str(&format!("{:0<58}", "line9 "));
+ content_to_send.push_str(&format!("{:0<58}", "line10 "));
+ content_to_send.push_str(&format!("{:0<58}", "line11 "));
+ content_to_send.push_str(&format!("{:0<58}", "line12 "));
+ content_to_send.push_str(&format!("{:0<58}", "line13 "));
+ content_to_send.push_str(&format!("{:0<58}", "line14 "));
+ content_to_send.push_str(&format!("{:0<58}", "line15 "));
+ content_to_send.push_str(&format!("{:0<58}", "line16 "));
+ content_to_send.push_str(&format!("{:0<58}", "line17 "));
+ content_to_send.push_str(&format!("{:0<58}", "line18 "));
+ content_to_send.push_str(&format!("{:0<58}", "line19 "));
+ content_to_send.push_str(&format!("{:0<57}", "line20 "));
+
+ remote_terminal.send_key(content_to_send.as_bytes());
+
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Scroll up inside pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(118, 20) {
+ // all lines have been written to the pane
+ remote_terminal.send_key(&SCROLL_MODE);
+ remote_terminal.send_key(&SCROLL_UP_IN_SCROLL_MODE);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for scroll to finish",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -247,8 +285,14 @@ pub fn scrolling_inside_a_pane() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -259,38 +303,44 @@ pub fn toggle_pane_fullscreen() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("toggle_pane_fullscreen", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Change newly opened pane to be fullscreen",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&TOGGLE_ACTIVE_TERMINAL_FULLSCREEN_IN_PANE_MODE);
- // back to normal mode after toggling fullscreen
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Change newly opened pane to be fullscreen",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&TOGGLE_ACTIVE_TERMINAL_FULLSCREEN_IN_PANE_MODE);
+ // back to normal mode after toggling fullscreen
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for pane to become fullscreen",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -300,8 +350,14 @@ pub fn toggle_pane_fullscreen() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -312,38 +368,44 @@ pub fn open_new_tab() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("open_new_tab", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Open new tab",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(&TAB_MODE);
- remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Open new tab",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for new tab to open",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -357,50 +419,146 @@ pub fn open_new_tab() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
#[test]
#[ignore]
-pub fn close_pane() {
+pub fn close_tab() {
let fake_win_size = Size {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("close_pane", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Open new tab",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
+ // back to normal mode
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Close tab",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(3, 2)
+ && remote_terminal.tip_appears()
+ && remote_terminal.snapshot_contains("Tab #2")
+ && remote_terminal.status_bar_appears()
+ {
+ // cursor is in the newly opened second tab
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&CLOSE_TAB_IN_TAB_MODE);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
+ name: "Wait for tab to close",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
+ if remote_terminal.cursor_position_is(3, 2)
+ && !remote_terminal.snapshot_contains("Tab #2")
{
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
+ // cursor is in the first tab again
step_is_complete = true;
}
step_is_complete
},
- })
- .add_step(Step {
- name: "Close pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&CLOSE_PANE_IN_PANE_MODE);
- // back to normal mode after close
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
+ assert_snapshot!(last_snapshot);
+}
+
+#[test]
+#[ignore]
+pub fn close_pane() {
+ let fake_win_size = Size {
+ cols: 120,
+ rows: 24,
+ };
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Close pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&CLOSE_PANE_IN_PANE_MODE);
+ // back to normal mode after close
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for pane to close",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -410,8 +568,14 @@ pub fn close_pane() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -422,8 +586,11 @@ pub fn exit_zellij() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("exit_zellij", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size).add_step(Step {
name: "Wait for app to load",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -434,8 +601,9 @@ pub fn exit_zellij() {
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ runner.run_all_steps();
+ break runner.take_snapshot_after(Step {
name: "Wait for app to exit",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -446,8 +614,8 @@ pub fn exit_zellij() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ };
assert!(last_snapshot.contains("Bye from Zellij!"));
}
@@ -458,8 +626,11 @@ pub fn closing_last_pane_exits_zellij() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("closing_last_pane_exits_zellij", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size).add_step(Step {
name: "Close pane",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -471,8 +642,13 @@ pub fn closing_last_pane_exits_zellij() {
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ runner.run_all_steps();
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ }
+ break runner.take_snapshot_after(Step {
name: "Wait for app to exit",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -481,50 +657,122 @@ pub fn closing_last_pane_exits_zellij() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ };
assert!(last_snapshot.contains("Bye from Zellij!"));
}
#[test]
#[ignore]
-pub fn resize_pane() {
+pub fn typing_exit_closes_pane() {
let fake_win_size = Size {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("resize_pane", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Resize pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Type exit",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ remote_terminal.send_key("e".as_bytes());
+ remote_terminal.send_key("x".as_bytes());
+ remote_terminal.send_key("i".as_bytes());
+ remote_terminal.send_key("t".as_bytes());
+ remote_terminal.send_key("\n".as_bytes());
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
+ name: "Wait for pane to close",
+ instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(&RESIZE_MODE);
- remote_terminal.send_key(&RESIZE_LEFT_IN_RESIZE_MODE);
- // back to normal mode after resizing
- remote_terminal.send_key(&ENTER);
+ // if remote_terminal.cursor_position_is(3, 2) && remote_terminal.tip_appears() {
+ if remote_terminal.cursor_position_is(3, 2) && remote_terminal.tip_appears() {
+ // cursor is in the original pane
step_is_complete = true;
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
+ assert_snapshot!(last_snapshot);
+}
+
+#[test]
+#[ignore]
+pub fn resize_pane() {
+ let fake_win_size = Size {
+ cols: 120,
+ rows: 24,
+ };
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Resize pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&RESIZE_MODE);
+ remote_terminal.send_key(&RESIZE_LEFT_IN_RESIZE_MODE);
+ // back to normal mode after resizing
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for pane to be resized",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -534,8 +782,14 @@ pub fn resize_pane() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -546,33 +800,39 @@ pub fn lock_mode() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("lock_mode", fake_win_size)
- .add_step(Step {
- name: "Enter lock mode",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&LOCK_MODE);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Send keys that should not be intercepted by the app",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.snapshot_contains("INTERFACE LOCKED") {
- remote_terminal.send_key(&TAB_MODE);
- remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
- remote_terminal.send_key("abc".as_bytes());
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Enter lock mode",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&LOCK_MODE);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Send keys that should not be intercepted by the app",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.snapshot_contains("INTERFACE LOCKED") {
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
+ remote_terminal.send_key("abc".as_bytes());
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for terminal to render sent keys",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -582,8 +842,14 @@ pub fn lock_mode() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -595,35 +861,41 @@ pub fn resize_terminal_window() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("resize_terminal_window", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Change terminal window size",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // new pane has been opened and focused
- remote_terminal.change_size(100, 24);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Change terminal window size",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // new pane has been opened and focused
+ remote_terminal.change_size(100, 24);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "wait for terminal to be resized and app to be re-rendered",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -633,8 +905,14 @@ pub fn resize_terminal_window() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -645,60 +923,66 @@ pub fn detach_and_attach_session() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("detach_and_attach_session", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Send some text to the active pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // new pane has been opened and focused
- remote_terminal.send_key("I am some text".as_bytes());
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Detach session",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(77, 2) {
- remote_terminal.send_key(&SESSION_MODE);
- remote_terminal.send_key(&DETACH_IN_SESSION_MODE);
- // text has been entered
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Reattach session",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if !remote_terminal.status_bar_appears() {
- // we don't see the toolbar, so we can assume we've already detached
- remote_terminal.attach_to_original_session();
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Send some text to the active pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // new pane has been opened and focused
+ remote_terminal.send_key("I am some text".as_bytes());
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Detach session",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(77, 2) {
+ remote_terminal.send_key(&SESSION_MODE);
+ remote_terminal.send_key(&DETACH_IN_SESSION_MODE);
+ // text has been entered
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Reattach session",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if !remote_terminal.status_bar_appears() {
+ // we don't see the toolbar, so we can assume we've already detached
+ remote_terminal.attach_to_original_session();
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for session to be attached",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -708,8 +992,14 @@ pub fn detach_and_attach_session() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -721,8 +1011,13 @@ pub fn accepts_basic_layout() {
rows: 24,
};
let layout_file_name = "three-panes-with-nesting.yaml";
- let last_snapshot = RemoteRunner::new_with_layout("accepts_basic_layout", fake_win_size, layout_file_name)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new_with_layout(fake_win_size, layout_file_name);
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for app to load",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -733,8 +1028,14 @@ pub fn accepts_basic_layout() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -746,34 +1047,40 @@ fn focus_pane_with_mouse() {
rows: 24,
};
- let last_snapshot = RemoteRunner::new("split_terminals_vertically", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Click left pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- remote_terminal.send_key(&normal_mouse_report(Position::new(5, 2), 0));
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Click left pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ remote_terminal.send_key(&normal_mouse_report(Position::new(5, 2), 0));
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for left pane to be focused",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -783,8 +1090,14 @@ fn focus_pane_with_mouse() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -795,66 +1108,73 @@ pub fn scrolling_inside_a_pane_with_mouse() {
cols: 120,
rows: 24,
};
- let last_snapshot = RemoteRunner::new("scrolling_inside_a_pane_with_mouse", fake_win_size)
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears() && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Fill terminal with text",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
- // cursor is in the newly opened second pane
- remote_terminal.send_key(format!("{:0<56}", "line1 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line2 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line3 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line4 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line5 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line6 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line7 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line8 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line9 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line10 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line11 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line12 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line13 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line14 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line15 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line16 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line17 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line18 ").as_bytes());
- remote_terminal.send_key(format!("{:0<58}", "line19 ").as_bytes());
- remote_terminal.send_key(format!("{:0<57}", "line20 ").as_bytes());
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Scroll up inside pane",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(118, 20) {
- // all lines have been written to the pane
- remote_terminal.send_key(&normal_mouse_report(Position::new(2, 64), 64));
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size)
+ .retry_pause_ms(1000) // we need a longer retry period here because it takes some time to fill the pty buffer
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Fill terminal with text",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(format!("{:0<56}", "line1 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line2 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line3 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line4 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line5 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line6 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line7 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line8 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line9 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line10 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line11 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line12 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line13 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line14 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line15 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line16 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line17 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line18 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<58}", "line19 ").as_bytes());
+ remote_terminal.send_key(format!("{:0<57}", "line20 ").as_bytes());
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Scroll up inside pane",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(118, 20) {
+ // all lines have been written to the pane
+ remote_terminal.send_key(&normal_mouse_report(Position::new(2, 64), 64));
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for scroll to finish",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -866,8 +1186,14 @@ pub fn scrolling_inside_a_pane_with_mouse() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -879,8 +1205,11 @@ pub fn start_without_pane_frames() {
rows: 24,
};
- let last_snapshot = RemoteRunner::new_without_frames("no_pane_frames", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new_without_frames(fake_win_size).add_step(Step {
name: "Split pane to the right",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -894,8 +1223,9 @@ pub fn start_without_pane_frames() {
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ runner.run_all_steps();
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for new pane to appear",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -905,8 +1235,14 @@ pub fn start_without_pane_frames() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
@@ -919,79 +1255,144 @@ pub fn mirrored_sessions() {
};
let mut test_attempts = 10;
let session_name = "mirrored_sessions";
- let mut last_snapshot = None;
- loop {
- // we run this test in a loop because there are some edge cases (especially in the CI)
- // where the second runner times out and then we also need to restart the first runner
- // if no test timed out, we break the loop and assert the snapshot
- let mut first_runner =
- RemoteRunner::new_with_session_name("mirrored_sessions", fake_win_size, session_name)
- .dont_panic()
- .add_step(Step {
- name: "Split pane to the right",
- instruction: |mut remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.status_bar_appears()
- && remote_terminal.cursor_position_is(3, 2)
- {
- remote_terminal.send_key(&PANE_MODE);
- remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
- // back to normal mode after split
- remote_terminal.send_key(&ENTER);
- step_is_complete = true;
- }
- step_is_complete
- },
- })
- .add_step(Step {
- name: "Wait for new pane to open",
- instruction: |remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2)
- && remote_terminal.tip_appears()
- {
- // cursor is in the newly opened second pane
- step_is_complete = true;
- }
- step_is_complete
- },
- });
+ let (first_runner_snapshot, second_runner_snapshot) = loop {
+ // here we connect with one runner, then connect with another, perform some actions and
+ // then make sure they were also reflected (mirrored) in the first runner afterwards
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut first_runner = RemoteRunner::new_with_session_name(fake_win_size, session_name)
+ .dont_panic()
+ .add_step(Step {
+ name: "Wait for app to load",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
first_runner.run_all_steps();
- let mut second_runner =
- RemoteRunner::new_existing_session("mirrored_sessions", fake_win_size, session_name)
- .dont_panic()
- .add_step(Step {
- name: "Make sure session appears correctly",
- instruction: |remote_terminal: RemoteTerminal| -> bool {
- let mut step_is_complete = false;
- if remote_terminal.cursor_position_is(63, 2)
- && remote_terminal.tip_appears()
- {
- // cursor is in the newly opened second pane
- step_is_complete = true;
- }
- step_is_complete
- },
- });
- let last_test_snapshot = second_runner.run_all_steps();
+ let mut second_runner = RemoteRunner::new_existing_session(fake_win_size, session_name)
+ .dont_panic()
+ .add_step(Step {
+ name: "Split pane to the right",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.status_bar_appears()
+ && remote_terminal.cursor_position_is(3, 2)
+ {
+ remote_terminal.send_key(&PANE_MODE);
+ remote_terminal.send_key(&SPLIT_RIGHT_IN_PANE_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Open new tab (second user)",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(63, 2) && remote_terminal.tip_appears() {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&NEW_TAB_IN_TAB_MODE);
+ // back to normal mode after split
+ remote_terminal.send_key(&ENTER);
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Wait for new tab to open",
+ instruction: |remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(3, 2)
+ && remote_terminal.tip_appears()
+ && remote_terminal.snapshot_contains("Tab #2")
+ && remote_terminal.status_bar_appears()
+ {
+ // cursor is in the newly opened second tab
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Switch to previous tab",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(3, 2)
+ && remote_terminal.tip_appears()
+ && remote_terminal.snapshot_contains("Tab #2")
+ {
+ // cursor is in the newly opened second pane
+ remote_terminal.send_key("some text".as_bytes());
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ })
+ .add_step(Step {
+ name: "Wait for text to appear on screen",
+ instruction: |mut remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.snapshot_contains("some text") {
+ remote_terminal.send_key(&TAB_MODE);
+ remote_terminal.send_key(&MOVE_FOCUS_LEFT_IN_PANE_MODE); // same key as tab mode
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ second_runner.run_all_steps();
+
+ if first_runner.test_timed_out || second_runner.test_timed_out {
+ test_attempts -= 1;
+ continue;
+ }
+ let second_runner_snapshot = second_runner.take_snapshot_after(Step {
+ name: "take snapshot after",
+ instruction: |remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(3, 2)
+ && remote_terminal.snapshot_contains("┐┌")
+ {
+ // cursor is back in the first tab
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
+ let first_runner_snapshot = first_runner.take_snapshot_after(Step {
+ name: "take snapshot after",
+ instruction: |remote_terminal: RemoteTerminal| -> bool {
+ let mut step_is_complete = false;
+ if remote_terminal.cursor_position_is(3, 2)
+ && remote_terminal.snapshot_contains("┐┌")
+ {
+ // cursor is back in the first tab
+ step_is_complete = true;
+ }
+ step_is_complete
+ },
+ });
if (first_runner.test_timed_out || second_runner.test_timed_out) && test_attempts >= 0 {
test_attempts -= 1;
continue;
} else {
- last_snapshot = Some(last_test_snapshot);
- break;
- }
- }
- match last_snapshot {
- Some(last_snapshot) => {
- assert_snapshot!(last_snapshot);
+ break (first_runner_snapshot, second_runner_snapshot);
}
- None => {
- panic!("test timed out before completing");
- }
- }
+ };
+ assert_snapshot!(first_runner_snapshot);
+ assert_snapshot!(second_runner_snapshot);
}
#[test]
@@ -1005,8 +1406,11 @@ pub fn bracketed_paste() {
// we make sure the text in bracketed paste mode is sent directly to the terminal and not
// interpreted by us (in this case it will send ^T to the terminal), then we exit bracketed
// paste, send some more text and make sure it's also sent to the terminal
- let last_snapshot = RemoteRunner::new("bracketed_paste", fake_win_size)
- .add_step(Step {
+ let mut test_attempts = 10;
+ let last_snapshot = loop {
+ RemoteRunner::kill_running_sessions(fake_win_size);
+ drop(());
+ let mut runner = RemoteRunner::new(fake_win_size).add_step(Step {
name: "Send pasted text followed by normal text",
instruction: |mut remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -1021,8 +1425,10 @@ pub fn bracketed_paste() {
}
step_is_complete
},
- })
- .add_step(Step {
+ });
+ runner.run_all_steps();
+
+ let last_snapshot = runner.take_snapshot_after(Step {
name: "Wait for terminal to render sent keys",
instruction: |remote_terminal: RemoteTerminal| -> bool {
let mut step_is_complete = false;
@@ -1032,7 +1438,13 @@ pub fn bracketed_paste() {
}
step_is_complete
},
- })
- .run_all_steps();
+ });
+ if runner.test_timed_out && test_attempts > 0 {
+ test_attempts -= 1;
+ continue;
+ } else {
+ break last_snapshot;
+ }
+ };
assert_snapshot!(last_snapshot);
}
diff --git a/src/tests/e2e/remote_runner.rs b/src/tests/e2e/remote_runner.rs
index d5d7a3e3..46e2b88f 100644
--- a/src/tests/e2e/remote_runner.rs
+++ b/src/tests/e2e/remote_runner.rs
@@ -1,3 +1,4 @@
+use std::sync::{Arc, Mutex};
use zellij_tile::data::Palette;
use zellij_server::panes::TerminalPane;
@@ -16,6 +17,7 @@ const CONNECTION_STRING: &str = "127.0.0.1:2222";
const CONNECTION_USERNAME: &str = "test";
const CONNECTION_PASSWORD: &str = "test";
const SESSION_NAME: &str = "e2e-test";
+const RETRIES: usize = 10;
fn ssh_connect() -> ssh2::Session {
let tcp = TcpStream::connect(CONNECTION_STRING).unwrap();
@@ -24,7 +26,16 @@ fn ssh_connect() -> ssh2::Session {
sess.handshake().unwrap();
sess.userauth_password(CONNECTION_USERNAME, CONNECTION_PASSWORD)
.unwrap();
- sess.set_timeout(3000);
+ sess
+}
+
+fn ssh_connect_without_timeout() -> ssh2::Session {
+ let tcp = TcpStream::connect(CONNECTION_STRING).unwrap();
+ let mut sess = Session::new().unwrap();
+ sess.set_tcp_stream(tcp);
+ sess.handshake().unwrap();
+ sess.userauth_password(CONNECTION_USERNAME, CONNECTION_PASSWORD)
+ .unwrap();
sess
}
@@ -107,6 +118,76 @@ fn start_zellij_with_layout(channel: &mut ssh2::Channel, layout_path: &str) {
channel.flush().unwrap();
}
+fn read_from_channel(
+ channel: &Arc<Mutex<ssh2::Channel>>,
+ last_snapshot: &Arc<Mutex<String>>,
+ cursor_coordinates: &Arc<Mutex<(usize, usize)>>,
+ pane_geom: &PaneGeom,
+) -> (Arc<Mutex<bool>>, std::thread::JoinHandle<()>) {
+ let should_keep_running = Arc::new(Mutex::new(true));
+ let thread = std::thread::Builder::new()
+ .name("read_thread".into())
+ .spawn({
+ let should_keep_running = should_keep_running.clone();
+ let channel = channel.clone();
+ let last_snapshot = last_snapshot.clone();
+ let cursor_coordinates = cursor_coordinates.clone();
+ let mut vte_parser = vte::Parser::new();
+ let mut terminal_output = TerminalPane::new(0, *pane_geom, Palette::default(), 0); // 0 is the pane index
+ let mut retries_left = 3;
+ move || {
+ let mut should_sleep = false;
+ loop {
+ if !*should_keep_running.lock().unwrap() {
+ break;
+ }
+ if should_sleep {
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ should_sleep = false;
+ }
+ let mut buf = [0u8; 1280000];
+ match channel.lock().unwrap().read(&mut buf) {
+ Ok(0) => {
+ let current_snapshot = take_snapshot(&mut terminal_output);
+ let mut last_snapshot = last_snapshot.lock().unwrap();
+ *cursor_coordinates.lock().unwrap() =
+ terminal_output.cursor_coordinates().unwrap_or((0, 0));
+ *last_snapshot = current_snapshot;
+ should_sleep = true;
+ }
+ Ok(count) => {
+ for byte in buf.iter().take(count) {
+ vte_parser.advance(&mut terminal_output.grid, *byte);
+ }
+ let current_snapshot = take_snapshot(&mut terminal_output);
+ let mut last_snapshot = last_snapshot.lock().unwrap();
+ *cursor_coordinates.lock().unwrap() =
+ terminal_output.grid.cursor_coordinates().unwrap_or((0, 0));
+ *last_snapshot = current_snapshot;
+ should_sleep = true;
+ }
+ Err(e) => {
+ if e.kind() == std::io::ErrorKind::WouldBlock {
+ let current_snapshot = take_snapshot(&mut terminal_output);
+ let mut last_snapshot = last_snapshot.lock().unwrap();
+ *cursor_coordinates.lock().unwrap() =
+ terminal_output.cursor_coordinates().unwrap_or((0, 0));
+ *last_snapshot = current_snapshot;
+ should_sleep = true;
+ } else if retries_left > 0 {
+ retries_left -= 1;
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ }
+ })
+ .unwrap();
+ (should_keep_running, thread)
+}
+
pub fn take_snapshot(terminal_output: &mut TerminalPane) -> String {
let output_lines = terminal_output.read_buffer_as_lines();
let cursor_coordinates = terminal_output.cursor_coordinates();
@@ -128,42 +209,44 @@ pub fn take_snapshot(terminal_output: &mut TerminalPane) -> String {
snapshot
}
-pub struct RemoteTerminal<'a> {
- channel: &'a mut ssh2::Channel,
+pub struct RemoteTerminal {
+ channel: Arc<Mutex<ssh2::Channel>>,
cursor_x: usize,
cursor_y: usize,
- current_snapshot: String,
+ last_snapshot: Arc<Mutex<String>>,
}
-impl<'a> std::fmt::Debug for RemoteTerminal<'a> {
+impl std::fmt::Debug for RemoteTerminal {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"cursor x: {}\ncursor_y: {}\ncurrent_snapshot:\n{}",
- self.cursor_x, self.cursor_y, self.current_snapshot
+ self.cursor_x,
+ self.cursor_y,
+ *self.last_snapshot.lock().unwrap()
)
}
}
-impl<'a> RemoteTerminal<'a> {
+impl RemoteTerminal {
pub fn cursor_position_is(&self, x: usize, y: usize) -> bool {
x == self.cursor_x && y == self.cursor_y
}
pub fn tip_appears(&self) -> bool {
- self.current_snapshot.contains("Tip:")
+ self.last_snapshot.lock().unwrap().contains("Tip:")
}
pub fn status_bar_appears(&self) -> bool {
- self.current_snapshot.contains("Ctrl +")
+ self.last_snapshot.lock().unwrap().contains("Ctrl +")
}
pub fn snapshot_contains(&self, text: &str) -> bool {
- self.current_snapshot.contains(text)
+ self.last_snapshot.lock().unwrap().contains(text)
}
#[allow(unused)]
pub fn current_snapshot(&self) -> String {
// convenience method for writing tests,
// this should only be used when developing,
// please prefer "snapsht_contains" instead
- self.current_snapshot.clone()
+ self.last_snapshot.lock().unwrap().clone()
}
#[allow(unused)]
pub fn current_cursor_position(&self) -> String {
@@ -173,21 +256,25 @@ impl<'a> RemoteTerminal<'a> {
format!("x: {}, y: {}", self.cursor_x, self.cursor_y)
}
pub fn send_key(&mut self, key: &[u8]) {
- self.channel.write_all(key).unwrap();
- self.channel.flush().unwrap();
+ let mut channel = self.channel.lock().unwrap();
+ channel.write_all(key).unwrap();
+ channel.flush().unwrap();
}
pub fn change_size(&mut self, cols: u32, rows: u32) {
self.channel
+ .lock()
+ .unwrap()
.request_pty_size(cols, rows, Some(cols), Some(rows))
.unwrap();
}
pub fn attach_to_original_session(&mut self) {
- self.channel
+ let mut channel = self.channel.lock().unwrap();
+ channel
.write_all(
format!("{} attach {}\n", ZELLIJ_EXECUTABLE_LOCATION, SESSION_NAME).as_bytes(),
)
.unwrap();
- self.channel.flush().unwrap();
+ channel.flush().unwrap();
}
}
@@ -200,26 +287,21 @@ pub struct Step {
pub struct RemoteRunner {
steps: Vec<Step>,
current_step_index: usize,
- vte_parser: vte::Parser,
- terminal_output: TerminalPane,
- channel: ssh2::Channel,
- test_name: &'static str,
+ channel: Arc<Mutex<ssh2::Channel>>,
currently_running_step: Option<String>,
retries_left: usize,
- win_size: Size,
- layout_file_name: Option<&'static str>,
- without_frames: bool,
- session_name: Option<String>,
- attach_to_existing: bool,
+ retry_pause_ms: usize,
panic_on_no_retries_left: bool,
+ last_snapshot: Arc<Mutex<String>>,
+ cursor_coordinates: Arc<Mutex<(usize, usize)>>, // x, y
+ reader_thread: (Arc<Mutex<bool>>, std::thread::JoinHandle<()>),
pub test_timed_out: bool,
}
impl RemoteRunner {
- pub fn new(test_name: &'static str, win_size: Size) -> Self {
+ pub fn new(win_size: Size) -> Self {
let sess = ssh_connect();
let mut channel = sess.channel_session().unwrap();
- let vte_parser = vte::Parser::new();
let mut rows = Dimension::fixed(win_size.rows);
let mut cols = Dimension::fixed(win_size.cols);
rows.set_inner(win_size.rows);
@@ -230,35 +312,38 @@ impl RemoteRunner {
rows,
cols,
};
- let terminal_output = TerminalPane::new(0, pane_geom, Palette::default(), 0); // 0 is the pane index
setup_remote_environment(&mut channel, win_size);
start_zellij(&mut channel);
+ let channel = Arc::new(Mutex::new(channel));
+ let last_snapshot = Arc::new(Mutex::new(String::new()));
+ let cursor_coordinates = Arc::new(Mutex::new((0, 0)));
+ sess.set_blocking(false);
+ let reader_thread =
+ read_from_channel(&channel, &last_snapshot, &cursor_coordinates, &pane_geom);
RemoteRunner {
steps: vec![],
channel,
- terminal_output,
- vte_parser,
- test_name,
currently_running_step: None,
current_step_index: 0,
- retries_left: 10,
- win_size,
- layout_file_name: None,
- without_frames: false,
- session_name: None,
- attach_to_existing: false,
+ retries_left: RETRIES,
+ retry_pause_ms: 100,
test_timed_out: false,
panic_on_no_retries_left: true,
+ last_snapshot,
+ cursor_coordinates,
+ reader_thread,
}
}
- pub fn new_with_session_name(
- test_name: &'static str,
- win_size: Size,
- session_name: &str,
- ) -> Self {
+ pub fn kill_running_sessions(win_size: Size) {
let sess = ssh_connect();
let mut channel = sess.channel_session().unwrap();
- let vte_parser = vte::Parser::new();
+ setup_remote_environment(&mut channel, win_size);
+ start_zellij(&mut channel);
+ }
+ pub fn new_with_session_name(win_size: Size, session_name: &str) -> Self {
+ // notice that this method does not have a timeout, so use with caution!
+ let sess = ssh_connect_without_timeout();
+ let mut channel = sess.channel_session().unwrap();
let mut rows = Dimension::fixed(win_size.rows);
let mut cols = Dimension::fixed(win_size.cols);
rows.set_inner(win_size.rows);
@@ -269,35 +354,31 @@ impl RemoteRunner {
rows,
cols,
};
- let terminal_output = TerminalPane::new(0, pane_geom, Palette::default(), 0); // 0 is the pane index
setup_remote_environment(&mut channel, win_size);
start_zellij_in_session(&mut channel, session_name);
+ let channel = Arc::new(Mutex::new(channel));
+ let last_snapshot = Arc::new(Mutex::new(String::new()));
+ let cursor_coordinates = Arc::new(Mutex::new((0, 0)));
+ sess.set_blocking(false);
+ let reader_thread =
+ read_from_channel(&channel, &last_snapshot, &cursor_coordinates, &pane_geom);
RemoteRunner {
steps: vec![],
channel,
- terminal_output,
- vte_parser,
- test_name,
currently_running_step: None,
current_step_index: 0,
- retries_left: 10,
- win_size,
- layout_file_name: None,
- without_frames: false,
- session_name: Some(String::from(session_name)),
- attach_to_existing: false,
+ retries_left: RETRIES,
+ retry_pause_ms: 100,
test_timed_out: false,
panic_on_no_retries_left: true,
+ last_snapshot,
+ cursor_coordinates,
+ reader_thread,
}
}
- pub fn new_existing_session(
- test_name: &'static str,
- win_size: Size,
- session_name: &str,
- ) -> Self {
- let sess = ssh_connect();
+ pub fn new_existing_session(win_size: Size, session_name: &str) -> Self {
+ let sess = ssh_connect_without_timeout();
let mut channel = sess.channel_session().unwrap();
- let vte_parser = vte::Parser::new();
let mut rows = Dimension::fixed(win_size.rows);
let mut cols = Dimension::fixed(win_size.cols);
rows.set_inner(win_size.rows);
@@ -308,31 +389,31 @@ impl RemoteRunner {
rows,
cols,
};
- let terminal_output = TerminalPane::new(0, pane_geom, Palette::default(), 0); // 0 is the pane index
setup_remote_environment(&mut channel, win_size);
attach_to_existing_session(&mut channel, session_name);
+ let channel = Arc::new(Mutex::new(channel));
+ let last_snapshot = Arc::new(Mutex::new(String::new()));
+ let cursor_coordinates = Arc::new(Mutex::new((0, 0)));
+ sess.set_blocking(false);
+ let reader_thread =
+ read_from_channel(&channel, &last_snapshot, &cursor_coordinates, &pane_geom);
RemoteRunner {
steps: vec![],
channel,
- terminal_output,
- vte_parser,
- test_name,
currently_running_step: None,
current_step_index: 0,
- retries_left: 10,
- win_size,
- layout_file_name: None,
- without_frames: false,
- session_name: Some(String::from(session_name)),
- attach_to_existing: true,
+ retries_left: RETRIES,
+ retry_pause_ms: 100,
test_timed_out: false,
panic_on_no_retries_left: true,
+ last_snapshot,
+ cursor_coordinates,
+ reader_thread,
}
}
- pub fn new_without_frames(test_name: &'static str, win_size: Size) -> Self {
+ pub fn new_without_frames(win_size: Size) -> Self {
let sess = ssh_connect();
let mut channel = sess.channel_session().unwrap();
- let vte_parser = vte::Parser::new();
let mut rows = Dimension::fixed(win_size.rows);
let mut cols = Dimension::fixed(win_size.cols);
rows.set_inner(win_size.rows);
@@ -343,36 +424,32 @@ impl RemoteRunner {
rows,
cols,
};
- let terminal_output = TerminalPane::new(0, pane_geom, Palette::default(), 0); // 0 is the pane index
setup_remote_environment(&mut channel, win_size);
start_zellij_without_frames(&mut channel);
+ let channel = Arc::new(Mutex::new(channel));
+ let last_snapshot = Arc::new(Mutex::new(String::new()));
+ let cursor_coordinates = Arc::new(Mutex::new((0, 0)));
+ sess.set_blocking(false);
+ let reader_thread =
+ read_from_channel(&channel, &last_snapshot, &cursor_coordinates, &pane_geom);
RemoteRunner {
steps: vec![],
channel,
- terminal_output,
- vte_parser,
- test_name,
currently_running_step: None,
current_step_index: 0,
- retries_left: 10,
- win_size,
- layout_file_name: None,
- without_frames: true,
- session_name: None,
- attach_to_existing: false,
+ retries_left: RETRIES,
+ retry_pause_ms: 100,
test_timed_out: false,
panic_on_no_retries_left: true,
+ last_snapshot,
+ cursor_coordinates,
+ reader_thread,
}
}
- pub fn new_with_layout(
- test_name: &'static str,
- win_size: Size,
- layout_file_name: &'static str,
- ) -> Self {
+ pub fn new_with_layout(win_size: Size, layout_file_name: &'static str) -> Self {
let remote_path = Path::new(ZELLIJ_LAYOUT_PATH).join(layout_file_name);
let sess = ssh_connect();
let mut channel = sess.channel_session().unwrap();
- let vte_parser = vte::Parser::new();
let mut rows = Dimension::fixed(win_size.rows);
let mut cols = Dimension::fixed(win_size.cols);
rows.set_inner(win_size.rows);
@@ -383,159 +460,104 @@ impl RemoteRunner {
rows,
cols,
};
- let terminal_output = TerminalPane::new(0, pane_geom, Palette::default(), 0); // 0 is the pane index
setup_remote_environment(&mut channel, win_size);
start_zellij_with_layout(&mut channel, &remote_path.to_string_lossy());
+ let channel = Arc::new(Mutex::new(channel));
+ let last_snapshot = Arc::new(Mutex::new(String::new()));
+ let cursor_coordinates = Arc::new(Mutex::new((0, 0)));
+ sess.set_blocking(false);
+ let reader_thread =
+ read_from_channel(&channel, &last_snapshot, &cursor_coordinates, &pane_geom);
RemoteRunner {
steps: vec![],
channel,
- terminal_output,
- vte_parser,
- test_name,
currently_running_step: None,
current_step_index: 0,
- retries_left: 10,
- win_size,
- layout_file_name: Some(layout_file_name),
- without_frames: false,
- session_name: None,
- attach_to_existing: false,
+ retries_left: RETRIES,
+ retry_pause_ms: 100,
test_timed_out: false,
panic_on_no_retries_left: true,
+ last_snapshot,
+ cursor_coordinates,
+ reader_thread,
}
}
pub fn dont_panic(mut self) -> Self {
self.panic_on_no_retries_left = false;
self
}
+ pub fn retry_pause_ms(mut self, retry_pause_ms: usize) -> Self {
+ self.retry_pause_ms = retry_pause_ms;
+ self
+ }
pub fn add_step(mut self, step: Step) -> Self {
self.steps.push(step);
self
}
- pub fn replace_steps(&mut self, steps: Vec<Step>) {
- self.steps = steps;
- }
- fn display_informative_error(&mut self) {
- let test_name = self.test_name;
- let current_step_name = self.currently_running_step.as_ref().cloned();
- match current_step_name {
- Some(current_step) => {
- let remote_terminal = self.current_remote_terminal_state();
- eprintln!("Timed out waiting for data on the SSH channel for test {}. Was waiting for step: {}", test_name, current_step);
- eprintln!("{:?}", remote_terminal);
- }
- None => {
- let remote_terminal = self.current_remote_terminal_state();
- eprintln!("Timed out waiting for data on the SSH channel for test {}. Haven't begun running steps yet.", test_name);
- eprintln!("{:?}", remote_terminal);
- }
- }
- }
- pub fn get_current_snapshot(&mut self) -> String {
- take_snapshot(&mut self.terminal_output)
- }
- fn current_remote_terminal_state(&mut self) -> RemoteTerminal {
- let current_snapshot = self.get_current_snapshot();
- let (cursor_x, cursor_y) = self.terminal_output.cursor_coordinates().unwrap_or((0, 0));
- RemoteTerminal {
- cursor_x,
- cursor_y,
- current_snapshot,
- channel: &mut self.channel,
- }
- }
pub fn run_next_step(&mut self) {
if let Some(next_step) = self.steps.get(self.current_step_index) {
- let current_snapshot = take_snapshot(&mut self.terminal_output);
- let (cursor_x, cursor_y) = self.terminal_output.cursor_coordinates().unwrap_or((0, 0));
+ let (cursor_x, cursor_y) = *self.cursor_coordinates.lock().unwrap();
let remote_terminal = RemoteTerminal {
cursor_x,
cursor_y,
- current_snapshot,
- channel: &mut self.channel,
+ last_snapshot: self.last_snapshot.clone(),
+ channel: self.channel.clone(),
};
let instruction = next_step.instruction;
self.currently_running_step = Some(String::from(next_step.name));
if instruction(remote_terminal) {
+ self.retries_left = RETRIES;
self.current_step_index += 1;
+ } else {
+ self.retries_left -= 1;
+ std::thread::sleep(std::time::Duration::from_millis(self.retry_pause_ms as u64));
}
}
}
pub fn steps_left(&self) -> bool {
self.steps.get(self.current_step_index).is_some()
}
- fn restart_test(&mut self) -> String {
- if let Some(layout_file_name) = self.layout_file_name.as_ref() {
- // let mut new_runner = RemoteRunner::new_with_layout(self.test_name, self.win_size, Path::new(&local_layout_path), session_name);
- let mut new_runner =
- RemoteRunner::new_with_layout(self.test_name, self.win_size, layout_file_name);
- new_runner.retries_left = self.retries_left - 1;
- new_runner.replace_steps(self.steps.clone());
- drop(std::mem::replace(self, new_runner));
- } else if self.without_frames {
- let mut new_runner = RemoteRunner::new_without_frames(self.test_name, self.win_size);
- new_runner.retries_left = self.retries_left - 1;
- new_runner.replace_steps(self.steps.clone());
- drop(std::mem::replace(self, new_runner));
- } else if self.session_name.is_some() {
- let mut new_runner = if self.attach_to_existing {
- RemoteRunner::new_existing_session(
- self.test_name,
- self.win_size,
- self.session_name.as_ref().unwrap(),
- )
- } else {
- RemoteRunner::new_with_session_name(
- self.test_name,
- self.win_size,
- self.session_name.as_ref().unwrap(),
- )
+ pub fn take_snapshot_after(&mut self, step: Step) -> String {
+ let mut retries_left = RETRIES;
+ let instruction = step.instruction;
+ loop {
+ if retries_left == 0 {
+ self.test_timed_out = true;
+ return self.last_snapshot.lock().unwrap().clone();
+ }
+ let (cursor_x, cursor_y) = *self.cursor_coordinates.lock().unwrap();
+ let remote_terminal = RemoteTerminal {
+ cursor_x,
+ cursor_y,
+ last_snapshot: self.last_snapshot.clone(),
+ channel: self.channel.clone(),
};
- new_runner.retries_left = self.retries_left - 1;
- new_runner.replace_steps(self.steps.clone());
- drop(std::mem::replace(self, new_runner));
- } else {
- let mut new_runner = RemoteRunner::new(self.test_name, self.win_size);
- new_runner.retries_left = self.retries_left - 1;
- new_runner.replace_steps(self.steps.clone());
- drop(std::mem::replace(self, new_runner));
+ if instruction(remote_terminal) {
+ return self.last_snapshot.lock().unwrap().clone();
+ } else {
+ retries_left -= 1;
+ std::thread::sleep(std::time::Duration::from_millis(100));
+ continue;
+ }
}
- self.run_all_steps()
}
- pub fn run_all_steps(&mut self) -> String {
- // returns the last snapshot
+ pub fn run_all_steps(&mut self) {
loop {
- let mut buf = [0u8; 1024];
- match self.channel.read(&mut buf) {
- Ok(0) => break,
- Ok(_count) => {
- for byte in buf.iter() {
- self.vte_parser
- .advance(&mut self.terminal_output.grid, *byte);
- }
- self.run_next_step();
- if !self.steps_left() {
- break;
- }
- }
- Err(e) => {
- if self.retries_left > 0 {
- return self.restart_test();
- }
- self.test_timed_out = true;
- if self.panic_on_no_retries_left {
- self.display_informative_error();
- panic!("timed out waiting for test: {:?}", e);
- }
- }
+ self.run_next_step();
+ if !self.steps_left() {
+ break;
+ } else if self.retries_left == 0 {
+ self.test_timed_out = true;
+ break;
}
}
- take_snapshot(&mut self.terminal_output)
}
}
impl Drop for RemoteRunner {
fn drop(&mut self) {
- let _ = self.channel.close();
+ let _ = self.channel.lock().unwrap().close();
+ let reader_thread_running = &mut self.reader_thread.0;
+ *reader_thread_running.lock().unwrap() = false;
}
}
diff --git a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__cannot_split_terminals_vertically_when_active_terminal_is_too_small.snap b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__cannot_split_terminals_vertically_when_active_terminal_is_too_small.snap
index 796a596b..ed01a3b9 100644
--- a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__cannot_split_terminals_vertically_when_active_terminal_is_too_small.snap
+++ b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__cannot_split_terminals_vertically_when_active_terminal_is_too_small.snap
@@ -22,4 +22,4 @@ expression: last_snapshot
│ │
└──────┘
Ctrl +
- ...
+
diff --git a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__close_tab.snap b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__close_tab.snap
index bbb5b068..bef865a1 100644
--- a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__close_tab.snap
+++ b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__close_tab.snap
@@ -1,29 +1,29 @@
---
-source: src/tests/integration/e2e.rs
+source: src/tests/e2e/cases.rs
expression: last_snapshot
---
- Zellij  Tab #1 
-
-$ │$ █
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
- │
-
- Ctrl + <g> LOCK  <p> PANE  <t> TAB  <r> RESIZE  <s> SCROLL  <o> SESSION  <q> QUIT 
- Tip: Alt + n => open new pane. Alt + [] or hjkl => navigate between panes.
+ Zellij (e2e-test)  Tab #1 
+┌ Pane #1 ─────────────────────────────────────────────────┐┌ Pane #2 ─────────────────────────────────────────────────┐
+│$ █ ││$ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+└──────────────────────────────────────────────────────────┘└──────────────────────────────────────────────────────────┘
+ Ctrl + <g> LOCK  <p> PANE  <t> TAB  <n> RESIZE  <h> MOVE  <s> SCROLL  <o> SESSION  <q> QUIT 
+ <←↓↑→> Move focus / <n> New / <x> Close / <r> Rename / <s> Sync / <Tab> Toggle / <ENTER> Select pane
diff --git a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions-2.snap b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions-2.snap
new file mode 100644
index 00000000..881e6289
--- /dev/null
+++ b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions-2.snap
@@ -0,0 +1,29 @@
+---
+source: src/tests/e2e/cases.rs
+expression: second_runner_snapshot
+
+---
+ Zellij (mirrored_sessions)  Tab #1  Tab #2 
+┌ Pane #1 ─────────────────────────────────────────────────┐┌ Pane #2 ─────────────────────────────────────────────────┐
+│$ █ ││$ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+│ ││ │
+└──────────────────────────────────────────────────────────┘└──────────────────────────────────────────────────────────┘
+ Ctrl + <g> LOCK  <p> PANE  <t> TAB  <n> RESIZE  <h> MOVE  <s> SCROLL  <o> SESSION  <q> QUIT 
+ <←↓↑→> Move focus / <n> New / <x> Close / <r> Rename / <s> Sync / <Tab> Toggle / <ENTER> Select pane
diff --git a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions.snap b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions.snap
index 1d975faf..7dbfbbd1 100644
--- a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions.snap
+++ b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__mirrored_sessions.snap
@@ -1,11 +1,11 @@
---
source: src/tests/e2e/cases.rs
-expression: last_snapshot
+expression: first_runner_snapshot
---
- Zellij (mirrored_sessions)  Tab #1 
+ Zellij (mirrored_sessions)  Tab #1  Tab #2 
┌ Pane #1 ─────────────────────────────────────────────────┐┌ Pane #2 ─────────────────────────────────────────────────┐
-│$ ││$ █ │
+│$ █ ││$ │
│ ││ │
│ ││ │
│ ││ │
@@ -26,4 +26,4 @@ expression: last_snapshot
│ ││ │
└──────────────────────────────────────────────────────────┘└──────────────────────────────────────────────────────────┘
Ctrl + <g> LOCK  <p> PANE  <t> TAB  <n> RESIZE  <h> MOVE  <s> SCROLL  <o> SESSION  <q> QUIT 
- Tip: Alt + <n> => new pane. Alt + <[] or hjkl> => navigate. Alt + <+-> => resize pane.
+ <←↓↑→> Move focus / <n> New / <x> Close / <r> Rename / <s> Sync / <Tab> Toggle / <ENTER> Select pane
diff --git a/src/tests/e2e/snapshots/zellij__tests__e2e__cases__typing_exit_closes_pane.snap b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__typing_exit_closes_pane.snap
new file mode 100644
index 00000000..e583c90b
--- /dev/null
+++ b/src/tests/e2e/snapshots/zellij__tests__e2e__cases__typing_exit_closes_pane.snap
@@ -0,0 +1,29 @@
+---
+source: src/tests/e2e/cases.rs
+expression: last_snapshot
+
+---
+ Zellij (e2e-test)  Tab #1 
+┌ Pane #1 ─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
+│$ █ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+│ │
+└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
+ Ctrl + <g> LOCK  <p> PANE  <t> TAB  <n> RESIZE  <h> MOVE  <s> SCROLL  <o> SESSION  <q> QUIT 
+ Tip: Alt + <n> => new pane. Alt + <[] or hjkl> => navigate. Alt + <+-> => resize pane.