Create integration test to check rebot command

.github/workflows/tests.yaml

@@ -14,7 +14,11 @@ jobs:
           - { os: ubuntu-latest,  target: x86_64-unknown-linux-gnu }
     steps:
       - uses: actions/checkout@v4
-
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+          cache: 'pip'
+      - run: pip install robotframework
       - uses: actions-rust-lang/[email protected]
         with:
           components: rustfmt, clippy

v2/robotmk/src/child_process_supervisor.rs

@@ -7,7 +7,7 @@ use log::{debug, error};
 use std::process::{ExitStatus, Stdio};
 use std::time::Duration;
 use sysinfo::{Pid, PidExt};
-use tokio::process::{Child, Command};
+use tokio::process::Command;
 use tokio_util::sync::CancellationToken;
 
 pub struct ChildProcessSupervisor<'a> {
@@ -22,12 +22,14 @@ pub struct StdioPaths {
     pub stderr: Utf8PathBuf,
 }
 
-fn wait_for_child(
+#[tokio::main]
+async fn wait_for_child(
     duration: Duration,
     flag: &CancellationToken,
-    child: &mut Child,
+    command: &mut Command,
 ) -> Result<ChildProcessOutcome> {
-    match waited(duration, flag, child.wait()) {
+    let child = &mut command.spawn().context("Failed to spawn subprocess")?;
+    match waited(duration, flag, child.wait()).await {
         Outcome::Timeout => {
             error!("Timed out");
             kill_child_tree(child);
@@ -65,7 +67,7 @@ impl ChildProcessSupervisor<'_> {
         wait_for_child(
             Duration::from_secs(self.timeout),
             self.cancellation_token,
-            &mut command.spawn().context("Failed to spawn subprocess")?,
+            &mut command,
         )
     }
 

v2/robotmk/src/results.rs

@@ -75,7 +75,7 @@ impl WritePiggybackSection for SuiteExecutionReport {
     }
 }
 
-#[derive(Serialize)]
+#[derive(Debug, Serialize)]
 pub enum AttemptOutcome {
     AllTestsPassed,
     TestFailures,

v2/robotmk/src/sessions/schtasks.rs

@@ -14,10 +14,11 @@ use sysinfo::Pid;
 use tokio::task::yield_now;
 use tokio_util::sync::CancellationToken;
 
-fn wait_for_task_exit(task: &TaskSpec, paths: &Paths) -> Result<RunOutcome> {
+#[tokio::main]
+async fn wait_for_task_exit(task: &TaskSpec, paths: &Paths) -> Result<RunOutcome> {
     let duration = Duration::from_secs(task.timeout);
     let queried = query(task.task_name, &paths.exit_code);
-    match waited(duration, task.cancellation_token, queried) {
+    match waited(duration, task.cancellation_token, queried).await {
         Outcome::Cancel => {
             kill_and_delete_task(task.task_name, paths);
             Ok(RunOutcome::TimedOut)

v2/robotmk/src/sessions/session.rs

@@ -34,14 +34,10 @@ impl Session {
 
 impl Display for Session {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        write!(
-            f,
-            "{}",
-            match self {
-                Self::Current(current_session) => format!("{}", current_session),
-                Self::User(user_session) => format!("{}", user_session),
-            }
-        )
+        match self {
+            Self::Current(current_session) => write!(f, "{}", current_session),
+            Self::User(user_session) => write!(f, "{}", user_session),
+        }
     }
 }
 

v2/robotmk/src/termination.rs

@@ -11,7 +11,6 @@ pub enum Outcome<T> {
     Completed(T),
 }
 
-#[tokio::main]
 pub async fn waited<F>(
     duration: Duration,
     flag: &CancellationToken,

v2/robotmk/tests/test_suite_run.rs

@@ -0,0 +1,32 @@
+use anyhow::Result;
+use camino::Utf8PathBuf;
+use robotmk::config::RetryStrategy;
+use robotmk::environment::{Environment, SystemEnvironment};
+use robotmk::rf::robot::Robot;
+use robotmk::sessions::session::{CurrentSession, Session};
+use robotmk::suites::run_attempts_with_rebot;
+use tempfile::tempdir;
+use tokio_util::sync::CancellationToken;
+
+#[test]
+fn test_rebot_run() -> Result<()> {
+    let test_dir = Utf8PathBuf::from_path_buf(tempdir()?.into_path()).unwrap();
+    let robot = Robot {
+        robot_target: "tests/minimal_suite/tasks.robot".into(),
+        n_attempts_max: 1,
+        command_line_args: vec![],
+        retry_strategy: RetryStrategy::Complete,
+    };
+    let (_attempt_outcomes, rebot) = run_attempts_with_rebot(
+        &robot,
+        "test",
+        &Environment::System(SystemEnvironment {}),
+        &Session::Current(CurrentSession {}),
+        3,
+        &CancellationToken::default(),
+        &test_dir,
+    )?;
+    println!("{:?}", _attempt_outcomes);
+    assert!(rebot.is_some());
+    Ok(())
+}

v2/robotmk/tests/timeout/minimal_suite/.gitignore

@@ -0,0 +1 @@
+tmp/

v2/robotmk/tests/timeout/minimal_suite/conda.yaml

@@ -0,0 +1,8 @@
+channels:
+  - conda-forge
+
+dependencies:
+  - python=3.11.6           
+  - pip=23.3.1 
+  - pip:
+      - robotframework==6.1.1

v2/robotmk/tests/timeout/minimal_suite/lib/add.py

@@ -0,0 +1,10 @@
+def setup() -> None:
+    print("Setting up...")
+
+
+def teardown() -> None:
+    print("Tearing down...")
+
+
+def add(left: int, right: int) -> int:
+    return left + right

v2/robotmk/tests/timeout/minimal_suite/robot.yaml

@@ -0,0 +1,12 @@
+tasks:
+  execute:
+    command:
+      - python
+      - --version
+
+condaConfigFile: conda.yaml
+artifactsDir: /tmp/outputdir   # Leading slash is ignored, instead we get $(pwd)/tmp/outputdir/
+PATH:
+  - .
+PYTHONPATH:
+  - .

v2/robotmk/tests/timeout/minimal_suite/tasks.robot

@@ -0,0 +1,21 @@
+*** Settings ***
+Documentation       Test file for configuring RobotFramework
+
+Library             ${CURDIR}/lib/add.py    WITH NAME    math
+
+Suite Setup         math.setup
+Suite Teardown      math.teardown
+
+
+*** Test Cases ***
+Addition One
+    ${result}=    math.add    ${20}    ${5}
+    Should Be Equal As Integers    ${result}    ${25}
+
+Addition Two
+    ${result}=    math.add    ${20}    ${15}
+    Should Be Equal As Integers    ${result}    ${35}
+
+Addition Three
+    ${result}=    math.add    ${20}    ${25}
+    Should Be Equal As Integers    ${result}    ${45}