aboutsummaryrefslogtreecommitdiff
path: root/tests/detach_reattach.rs
diff options
context:
space:
mode:
authorOgulcan Celik <ogulcancelik@gmail.com>2026-06-29 20:39:54 +0300
committerOgulcan Celik <ogulcancelik@gmail.com>2026-06-29 20:39:54 +0300
commit8b74fb8a12716269c76f0b503ee7db5bbec2c921 (patch)
treee5230f94cb1e6eb70d1f00c75cd85dae8b5b9ead /tests/detach_reattach.rs
parent5fffc59cd8aaea1604abb90e749e58fd97acfac0 (diff)
feat: emit placement mutation events
Diffstat (limited to 'tests/detach_reattach.rs')
-rw-r--r--tests/detach_reattach.rs58
1 files changed, 29 insertions, 29 deletions
diff --git a/tests/detach_reattach.rs b/tests/detach_reattach.rs
index cfcb5b89..3abe1bec 100644
--- a/tests/detach_reattach.rs
+++ b/tests/detach_reattach.rs
@@ -16,7 +16,7 @@ use serde_json::Value;
use support::{
cleanup_test_base, client_handshake, drain_messages, read_server_message, register_runtime_dir,
register_spawned_herdr_pid, send_detach, send_input, unregister_spawned_herdr_pid,
- wait_for_disconnect, wait_for_message_variant, wait_for_socket, wait_until,
+ wait_for_disconnect, wait_for_message_variant, wait_for_socket, wait_until, CURRENT_PROTOCOL,
};
fn unique_test_dir() -> PathBuf {
@@ -276,8 +276,8 @@ fn navigate_q_detaches_client_and_server_persists() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
let (version, error) =
- client_handshake(&mut stream, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ client_handshake(&mut stream, CURRENT_PROTOCOL, 80, 24).expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@@ -338,8 +338,8 @@ fn explicit_detach_message_causes_clean_disconnect() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
- client_handshake(&mut stream, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ client_handshake(&mut stream, CURRENT_PROTOCOL, 80, 24).expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@@ -396,9 +396,9 @@ fn reattach_after_detach_shows_current_state() {
// --- Client A ---
let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
- let (version, error) =
- client_handshake(&mut stream_a, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_a, CURRENT_PROTOCOL, 80, 24)
+ .expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@@ -435,9 +435,9 @@ fn reattach_after_detach_shows_current_state() {
// --- Client B (reattach) ---
let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
- let (version, error) =
- client_handshake(&mut stream_b, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_b, CURRENT_PROTOCOL, 80, 24)
+ .expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(
error.is_none(),
"reattach handshake should succeed: {:?}",
@@ -516,8 +516,8 @@ fn processes_survive_during_and_after_detach() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
- client_handshake(&mut stream, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ client_handshake(&mut stream, CURRENT_PROTOCOL, 80, 24).expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@@ -554,9 +554,9 @@ fn processes_survive_during_and_after_detach() {
// Reattach — verify we can connect and receive a frame.
let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
- let (version, error) =
- client_handshake(&mut stream_b, 14, 80, 24).expect("reattach handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_b, CURRENT_PROTOCOL, 80, 24)
+ .expect("reattach handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Verify the reattached client receives a frame.
@@ -604,8 +604,8 @@ fn server_persists_after_client_connection_drop() {
// Connect and handshake.
let mut stream = UnixStream::connect(&client_socket).expect("should connect");
let (version, error) =
- client_handshake(&mut stream, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ client_handshake(&mut stream, CURRENT_PROTOCOL, 80, 24).expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Drain initial frames.
@@ -630,9 +630,9 @@ fn server_persists_after_client_connection_drop() {
// Reattach — verify we can connect and handshake again.
let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
- let (version, error) =
- client_handshake(&mut stream_b, 14, 80, 24).expect("reattach handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_b, CURRENT_PROTOCOL, 80, 24)
+ .expect("reattach handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "reattach should succeed: {:?}", error);
cleanup_spawned_herdr(spawned, base);
@@ -653,8 +653,8 @@ fn detached_output_preserves_last_attached_pty_size() {
let mut stream = UnixStream::connect(&client_socket).expect("client should connect");
let (version, error) =
- client_handshake(&mut stream, 14, 120, 40).expect("handshake should succeed");
- assert_eq!(version, 14);
+ client_handshake(&mut stream, CURRENT_PROTOCOL, 120, 40).expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
drain_messages(&mut stream);
@@ -721,9 +721,9 @@ fn output_accumulated_while_detached_visible_on_reattach() {
// Connect and handshake client A.
let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
- let (version, error) =
- client_handshake(&mut stream_a, 14, 80, 24).expect("handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_a, CURRENT_PROTOCOL, 80, 24)
+ .expect("handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Detach client A immediately.
@@ -779,9 +779,9 @@ fn output_accumulated_while_detached_visible_on_reattach() {
// --- Client B (reattach) ---
let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
- let (version, error) =
- client_handshake(&mut stream_b, 14, 80, 24).expect("reattach handshake should succeed");
- assert_eq!(version, 14);
+ let (version, error) = client_handshake(&mut stream_b, CURRENT_PROTOCOL, 80, 24)
+ .expect("reattach handshake should succeed");
+ assert_eq!(version, CURRENT_PROTOCOL);
assert!(error.is_none(), "{:?}", error);
// Client B should receive a frame with the current state.