Workflows

.github/workflows/test.yml

@@ -0,0 +1,35 @@
+name: Tests
+
+on:
+  #workflow_call:
+  pull_request:
+
+env:
+  RUST_BACKTRACE: full
+  ANTICIPATE_ECHO: true
+
+jobs:
+  check:
+    name: Run test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - os: ubuntu-latest
+          #- os: windows-latest
+          - os: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: ⚡ Cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Run tests
+        run: |
+          cargo test --all -- --nocapture

core/src/error.rs

@@ -1,9 +1,5 @@
-use std::error;
-use std::fmt;
-use std::fmt::Display;
-use std::io;
-
 use thiserror::Error;
+use std::time::Duration;
 
 /// Error type for the library.
 #[derive(Debug, Error)]
@@ -15,8 +11,8 @@ pub enum Error {
     #[error("failed to parse regex")]
     RegexParsing,
     /// An timeout was reached while waiting in expect call.
-    #[error("reached the timeout for an expectation")]
-    ExpectTimeout,
+    #[error("reached the timeout for an expectation ({0:?})")]
+    ExpectTimeout(Duration),
     /// Unhandled EOF error.
     #[error("unhandled EOF")]
     Eof,
@@ -28,11 +24,3 @@ pub enum Error {
     #[error(transparent)]
     Conpty(#[from] conpty::error::Error),
 }
-
-pub(crate) fn to_io_error<E: Display>(
-    message: &'static str,
-) -> impl FnOnce(E) -> io::Error {
-    move |e: E| {
-        io::Error::new(io::ErrorKind::Other, format!("{}; {}", message, e))
-    }
-}

core/src/lib.rs

@@ -1,7 +1,7 @@
 #![warn(missing_docs)]
 #![forbid(unsafe_code)]
-//! Control a pseudo-terminal similar to `expect(1)`, 
-//! fork of [expectrl](https://docs.rs/expectrl) with 
+//! Control a pseudo-terminal similar to `expect(1)`,
+//! fork of [expectrl](https://docs.rs/expectrl) with
 //! minimal dependencies and features.
 
 mod captures;

core/src/process/unix.rs

@@ -1,7 +1,6 @@
 //! This module contains a Unix implementation of [crate::process::Process].
 
 use super::{Healthcheck, NonBlocking, Process};
-use crate::error::to_io_error;
 use ptyprocess::{stream::Stream, PtyProcess};
 
 use std::{
@@ -37,27 +36,20 @@ impl Process for UnixProcess {
     }
 
     fn spawn_command(command: Self::Command) -> Result<Self> {
-        let proc = PtyProcess::spawn(command)
-            .map_err(to_io_error("Failed to spawn a command"))?;
-
+        let proc = PtyProcess::spawn(command)?;
         Ok(Self { proc })
     }
 
     fn open_stream(&mut self) -> Result<Self::Stream> {
-        let stream = self
-            .proc
-            .get_pty_stream()
-            .map_err(to_io_error("Failed to create a stream"))?;
+        let stream = self.proc.get_pty_stream()?;
         let stream = PtyStream::new(stream);
         Ok(stream)
     }
 }
 
 impl Healthcheck for UnixProcess {
     fn is_alive(&mut self) -> Result<bool> {
-        self.proc
-            .is_alive()
-            .map_err(to_io_error("Failed to call pty.is_alive()"))
+        Ok(self.proc.is_alive()?)
     }
 }
 

core/src/process/windows.rs

@@ -24,13 +24,14 @@ impl ProcessTrait for WinProcess {
     type Stream = ProcessStream;
 
     fn spawn<S: AsRef<str>>(cmd: S) -> Result<Self> {
-        Ok(spawn(cmd.as_ref())
-            .map(|proc| WinProcess { proc })?)
+        Ok(spawn(cmd.as_ref()).map(|proc| WinProcess { proc })?)
     }
 
     fn spawn_command(command: Self::Command) -> Result<Self> {
-        Ok(conpty::Process::spawn(command)
-            .map(|proc| WinProcess { proc })?)
+        Ok(
+            conpty::Process::spawn(command)
+                .map(|proc| WinProcess { proc })?,
+        )
     }
 
     fn open_stream(&mut self) -> Result<Self::Stream> {

core/src/repl.rs

@@ -2,7 +2,7 @@
 
 use crate::{
     error::Error,
-    log::{NoopLogWriter, LogWriter},
+    log::{LogWriter, NoopLogWriter},
     spawn, Captures, Expect, Needle, Session,
 };
 use std::ops::{Deref, DerefMut};

core/src/session/session.rs

@@ -170,7 +170,7 @@ impl<O: LogWriter, P, S: Read + NonBlocking> Session<O, P, S> {
 
             if let Some(timeout) = self.expect_timeout {
                 if start.elapsed() > timeout {
-                    return Err(Error::ExpectTimeout);
+                    return Err(Error::ExpectTimeout(timeout));
                 }
             }
         }
@@ -230,7 +230,7 @@ impl<O: LogWriter, P, S: Read + NonBlocking> Session<O, P, S> {
 
             if let Some(timeout) = self.expect_timeout {
                 if start.elapsed() > timeout {
-                    return Err(Error::ExpectTimeout);
+                    return Err(Error::ExpectTimeout(timeout));
                 }
             }
         }
@@ -440,10 +440,6 @@ struct TryStream<S> {
 }
 
 impl<S> TryStream<S> {
-    fn into_inner(self) -> S {
-        self.stream.inner.into_inner().inner
-    }
-
     fn as_ref(&self) -> &S {
         &self.stream.inner.get_ref().inner
     }
@@ -460,17 +456,9 @@ impl<S: Read> TryStream<S> {
             stream: ControlledReader::new(stream),
         })
     }
-
-    fn flush_in_buffer(&mut self) {
-        self.stream.flush_in_buffer();
-    }
 }
 
 impl<S> TryStream<S> {
-    fn keep_in_buffer(&mut self, v: &[u8]) {
-        self.stream.keep_in_buffer(v);
-    }
-
     fn get_available(&mut self) -> &[u8] {
         self.stream.get_available()
     }

core/tests/conpty.rs

@@ -0,0 +1,9 @@
+#[test]
+#[cfg(windows)]
+fn conpty_echo() {
+    let mut proc = conpty::spawn("echo Hello World").unwrap();
+    let mut reader = proc.output().unwrap();
+    let mut buf = [0; 1024];
+    reader.read(&mut buf).unwrap();
+    assert!(String::from_utf8_lossy(&buf).contains("Hello World"));
+}

core/tests/expect.rs

@@ -15,8 +15,9 @@ fn expect_str() {
 #[test]
 fn expect_str() {
     let mut session =
-        spawn(r#"powershell -c "python ./tests/actions/cat/main.py""#).unwrap();
-    session.send_line("Hello World\n\r").unwrap();
+        spawn(r#"pwsh -c "python ./tests/actions/cat/main.py""#)
+            .unwrap();
+    session.send_line("Hello World").unwrap();
     session.expect("Hello World").unwrap();
 }
 
@@ -45,10 +46,10 @@ fn expect_regex_lazy() {
 #[test]
 fn expect_regex() {
     let mut session =
-        spawn("python ./tests/actions/echo/main.py Hello World").unwrap();
+        spawn("echo 'Hello World'").unwrap();
     let m = session.expect(Regex("lo.*")).unwrap();
     assert_eq!(m.matches().count(), 1);
-    assert_eq!(m.get(0).unwrap(), b"lo World\r");
+    assert_eq!(m.get(0).unwrap(), b"lo World'\r");
 }
 
 #[cfg(unix)]
@@ -134,7 +135,7 @@ fn expect_eof_timeout() {
     let mut p = spawn("sleep 3").expect("cannot run sleep 3");
     p.set_expect_timeout(Some(Duration::from_millis(100)));
     match p.expect(Eof) {
-        Err(anticipate::Error::ExpectTimeout) => {}
+        Err(anticipate::Error::ExpectTimeout(_)) => {}
         r => panic!("reached a timeout {r:?}"),
     }
 }
@@ -145,7 +146,7 @@ fn expect_eof_timeout() {
     let mut p = spawn("sleep 3").expect("cannot run sleep 3");
     p.set_expect_timeout(Some(Duration::from_millis(100)));
     match p.expect(Eof) {
-        Err(anticipate::Error::ExpectTimeout) => {}
+        Err(anticipate::Error::ExpectTimeout(_)) => {}
         r => panic!("should raise TimeOut {:?}", r),
     }
 }

core/tests/io.rs

@@ -21,7 +21,7 @@ fn send_controll() {
 #[cfg(windows)]
 fn send_controll() {
     let mut proc =
-        DefaultSession::spawn(Command::new("powershell -C ping localhost"))
+        DefaultSession::spawn(Command::new("pwsh -C ping localhost"))
             .unwrap();
 
     // give powershell a bit time
@@ -129,7 +129,7 @@ fn try_read_by_byte() {
     // it shows that on windows ECHO is turned on.
     // Mustn't it be turned down?
 
-    let mut proc = DefaultSession::spawn(Command::new("powershell")).unwrap();
+    let mut proc = DefaultSession::spawn(Command::new("pwsh")).unwrap();
     _p_send_line(
         &mut proc,
         "while (1) { read-host | set r; if (!$r) { break }}",
@@ -188,7 +188,7 @@ fn blocking_read_after_non_blocking() {
 #[test]
 #[cfg(windows)]
 fn blocking_read_after_non_blocking() {
-    let mut proc = DefaultSession::spawn(Command::new("powershell")).unwrap();
+    let mut proc = DefaultSession::spawn(Command::new("pwsh")).unwrap();
     _p_send_line(
         &mut proc,
         "while (1) { read-host | set r; if (!$r) { break }}",
@@ -241,7 +241,7 @@ fn try_read() {
 #[test]
 #[cfg(windows)]
 fn try_read() {
-    let mut proc = DefaultSession::spawn(Command::new("powershell")).unwrap();
+    let mut proc = DefaultSession::spawn(Command::new("pwsh")).unwrap();
     thread::sleep(Duration::from_millis(300));
     _p_send_line(
         &mut proc,

runner/src/interpreter.rs

@@ -2,7 +2,7 @@ use crate::{
     resolve_path, Error, Instruction, Instructions, Result, ScriptParser,
 };
 use anticipate::{
-    log::{NoopLogWriter, LogWriter, PrefixLogWriter, StandardLogWriter},
+    log::{LogWriter, NoopLogWriter, PrefixLogWriter, StandardLogWriter},
     repl::ReplSession,
     spawn_with_options, ControlCode, Expect, Regex, Session,
 };
@@ -20,7 +20,12 @@ use tracing::{span, Level};
 use unicode_segmentation::UnicodeSegmentation;
 
 const PROMPT: &str = "➜ ";
+#[cfg(unix)]
+const COMMAND: &str = "bash -noprofile -norc";
+#[cfg(windows)]
+const COMMAND: &str = "pwsh -NoProfile -NonInteractive -NoLogo";
 
+/// Source for probability distribution.
 struct Source<T>(T);
 
 impl<T: rand::RngCore> source::Source for Source<T> {
@@ -52,10 +57,7 @@ impl Default for CinemaOptions {
             delay: 75,
             type_pragma: false,
             deviation: 15.0,
-            #[cfg(unix)]
-            shell: "sh -noprofile -norc".to_string(),
-            #[cfg(windows)]
-            shell: "powershell".to_string(),
+            shell: COMMAND.to_string(),
             cols: 80,
             rows: 24,
         }
@@ -85,15 +87,12 @@ pub struct InterpreterOptions {
 impl Default for InterpreterOptions {
     fn default() -> Self {
         Self {
-            #[cfg(unix)]
-            command: "sh -noprofile -norc".to_owned(),
-            #[cfg(windows)]
-            command: "powershell".to_string(),
+            command: COMMAND.to_owned(),
             prompt: None,
-            timeout: Some(5000),
+            timeout: Some(10000),
             cinema: None,
             id: None,
-            echo: false,
+            echo: std::env::var("ANTICIPATE_ECHO").ok().is_some(),
             format: false,
             print_comments: false,
         }
@@ -109,7 +108,7 @@ impl InterpreterOptions {
         print_comments: bool,
     ) -> Self {
         Self {
-            command: "sh -noprofile -norc".to_owned(),
+            command: COMMAND.to_owned(),
             prompt: None,
             timeout: Some(timeout),
             cinema: None,
@@ -291,7 +290,8 @@ impl ScriptFile {
                 spawn_with_options(cmd, None, timeout)?;
             start(pty, prompt, options, pragma, instructions)?;
         } else if options.echo && !options.format {
-            let pty = spawn_with_options(cmd, Some(StandardLogWriter), timeout)?;
+            let pty =
+                spawn_with_options(cmd, Some(StandardLogWriter), timeout)?;
             start(pty, prompt, options, pragma, instructions)?;
         } else if options.echo && options.format {
             let pty =

tests/fixtures/echo.sh

@@ -1,3 +1,2 @@
 echo "hello world"
 #$ expect hello world
-exit

tests/fixtures/escaped-newline.sh

@@ -1,4 +1,3 @@
 echo \
   "hello world"
 #$ expect hello world
-exit