#pty #automation #testing #expect #pexpect

dev rexpect

Interact with unix processes/bash the same way as pexpect or Don libes expect does

4 releases (2 breaking)

0.3.0 Feb 25, 2018
0.2.0 Sep 27, 2017
0.1.1 Aug 19, 2017
0.1.0 Jul 27, 2017

#93 in Unix APIs

Download history 217/week @ 2019-12-01 370/week @ 2019-12-08 130/week @ 2019-12-15 37/week @ 2019-12-22 30/week @ 2019-12-29 269/week @ 2020-01-05 282/week @ 2020-01-12 48/week @ 2020-01-19 87/week @ 2020-01-26 107/week @ 2020-02-02 121/week @ 2020-02-09 143/week @ 2020-02-16 81/week @ 2020-02-23 60/week @ 2020-03-01 76/week @ 2020-03-08 135/week @ 2020-03-15

688 downloads per month
Used in 6 crates

MIT license

698 lines

Build Status crates.io

Documentation (Development)

The goal is to offer a similar set of functionality as pexpect.

Basic usage

Add this to your Cargo.toml

rexpect = "0.3"

Simple example for interacting via ftp:

extern crate rexpect;

use rexpect::spawn;
use rexpect::errors::*;

fn do_ftp() -> Result<()> {
    let mut p = spawn("ftp speedtest.tele2.net", Some(30_000))?;
    p.exp_regex("Name \\(.*\\):")?;
    p.send_line("cd upload")?;
    p.exp_string("successfully changed.\r\nftp>")?;
    p.exp_regex("[0-9]+ \"/upload\"")?;

fn main() {
    do_ftp().unwrap_or_else(|e| panic!("ftp job failed with {}", e));

Example with bash and reading from programs

extern crate rexpect;
use rexpect::spawn_bash;
use rexpect::errors::*;

fn foo() -> Result<()> {
    let mut p = spawn_bash(Some(2000))?;
    // case 1: wait until program is done
    let hostname = p.read_line()?;
    p.wait_for_prompt()?; // go sure `hostname` is really done
    println!("Current hostname: {}", hostname);

    // case 2: wait until done, only extract a few infos
    p.send_line("wc /etc/passwd")?;
    // `exp_regex` returns both string-before-match and match itself, discard first
    let (_, lines) = p.exp_regex("[0-9]+")?;
    let (_, words) = p.exp_regex("[0-9]+")?;
    let (_, bytes) = p.exp_regex("[0-9]+")?;
    p.wait_for_prompt()?; // go sure `wc` is really done
    println!("/etc/passwd has {} lines, {} words, {} chars", lines, words, bytes);

    // case 3: read while program is still executing
    p.execute("ping", "bytes of data")?; // returns when it sees "bytes of data" in output
    for _ in 0..5 {
        // times out if one ping takes longer than 2s
        let (_, duration) = p.exp_regex("[0-9. ]+ ms")?;
        println!("Roundtrip time: {}", duration);

Example with bash and job control

One frequent bitfall with sending ctrl-c and friends is that you need to somehow ensure that the program has fully loaded, otherwise the ctrl-* goes into nirvana. There are two functions to ensure that:

  • execute where you need to provide a match string which is present on stdout/stderr when the program is ready
  • wait_for_prompt which waits until the prompt is shown again
extern crate rexpect;
use rexpect::spawn_bash;
use rexpect::errors::*;

fn run() -> Result<()> {
    let mut p = spawn_bash(Some(1000))?;
    p.execute("ping", "bytes of data")?;
    // bash writes 'ping' to stdout again to state which job was put into background
    p.execute("bg", "ping")?;
    p.send_line("sleep 1")?;
    // bash writes 'ping' to stdout again to state which job was put into foreground
    p.execute("fg", "ping")?;
    p.exp_string("packet loss")?;

Project Status

Rexpect covers more or less the features of pexpect. If you miss anything I'm happy to receive PRs or also Issue requests of course.

The tests cover most of the aspects and it should run out of the box for rust stable, beta and nightly on both Linux or Mac.

That said, I don't know of too many people using it yet, so use this with caution.

Design decisions

  • use error handling of error-chain
  • use nix (and avoid libc wherever possible) to keep the code safe and clean
  • sadly, expect is used in rust too prominently to unwrap Options and Results, use exp_* instead


~97K SLoC