Struct MockConn 

pub struct MockConn {
    pub written: Mutex<Vec<u8>>,
    pub read_data: Mutex<Vec<u8>>,
    pub started: AtomicBool,
    pub killed: AtomicBool,
    pub closed: AtomicBool,
    pub mock_exit_code: i32,
    pub term_size: Mutex<(i64, i64)>,
    pub wait_tx: Mutex<Option<Sender<()>>>,
    pub wait_rx: Mutex<Option<Receiver<()>>>,
}

Mock ConnInterface for testing without a real PTY.

Fields

written: Mutex<Vec<u8>>

Data written to this mock (simulates stdin).

read_data: Mutex<Vec<u8>>

Data to return from read (simulates stdout).

started: AtomicBool

Whether the process has been started.

killed: AtomicBool

Whether the process has been killed.

closed: AtomicBool

Whether the process has been closed.

mock_exit_code: i32

Exit code to return.

term_size: Mutex<(i64, i64)>

Current terminal size.

wait_tx: Mutex<Option<Sender<()>>>

Notify when wait should return (simulate process exit).

wait_rx: Mutex<Option<Receiver<()>>>

Implementations

impl MockConn

pub fn new(mock_exit_code: i32) -> Self

pub fn set_read_data(&self, data: Vec<u8>)

Set data that will be returned by read_data.

pub fn signal_exit(&self)

Signal that the mock process should exit.

pub fn get_written(&self) -> Vec<u8>

Get all data written to the mock.

Trait Implementations

impl ConnInterface for MockConn

fn start(&mut self) -> Result<()>

Start the process. Called once after creation.

fn wait(&mut self) -> Result<i32>

Wait for process to exit. Returns exit status as error.

fn kill(&self) -> Result<()>

Kill the process immediately.

fn kill_graceful(&self, _timeout_ms: u64) -> Result<()>

Kill the process gracefully with a timeout.

fn exit_code(&self) -> i32

Get the process exit code (only valid after wait returns).

fn write_data(&self, data: &[u8]) -> Result<usize>

Write data to process stdin/PTY.

fn read_data(&self, buf: &mut [u8]) -> Result<usize>

Read data from process stdout/PTY.

fn set_size(&self, rows: i64, cols: i64) -> Result<()>

Resize the PTY.

fn close(&self) -> Result<()>

Close the connection.