test: suspend() then notify()

Cargo.toml

@@ -153,6 +153,7 @@ tempfile = "3.10"
 # testing
 escargot = "0.5"
 pretty_assertions = "1.4"
+serial_test = "3.1"
 test-case = "3.3"
 test_each_file = "0.3"
 unindent = "0.2"

crates/kernel/testsuite/moot_suite.rs

@@ -17,15 +17,9 @@
 //! See example.moot for a full-fledged example
 
 mod common;
-use std::{
-    fs::File,
-    io::{BufRead, BufReader},
-    path::Path,
-    sync::{Arc, Once},
-};
+use std::{path::Path, sync::Arc};
 
 use common::{create_wiredtiger_db, testsuite_dir};
-use eyre::Context;
 use moor_db::Database;
 use moor_kernel::{
     config::Config,
@@ -35,7 +29,7 @@ use moor_kernel::{
         sessions::{NoopClientSession, Session},
     },
 };
-use moor_moot::{MootRunner, MootState, WIZARD};
+use moor_moot::{execute_moot_test, MootRunner};
 use moor_values::var::{v_none, Objid, Var};
 
 #[cfg(feature = "relbox")]
@@ -95,51 +89,21 @@ fn test_wiredtiger(path: &Path) {
 }
 test_each_file::test_each_path! { in "./crates/kernel/testsuite/moot" as wiredtiger => test_wiredtiger }
 
-#[allow(dead_code)]
-static LOGGING_INIT: Once = Once::new();
-#[allow(dead_code)]
-fn init_logging() {
-    LOGGING_INIT.call_once(|| {
-        let main_subscriber = tracing_subscriber::fmt()
-            .compact()
-            .with_ansi(true)
-            .with_file(true)
-            .with_line_number(true)
-            .with_thread_names(true)
-            .with_max_level(tracing::Level::WARN)
-            .with_test_writer()
-            .finish();
-        tracing::subscriber::set_global_default(main_subscriber)
-            .expect("Unable to set configure logging");
-    });
-}
-
 fn test(db: Arc<dyn Database + Send + Sync>, path: &Path) {
-    init_logging();
     if path.is_dir() {
         return;
     }
-    eprintln!("Test definition: {}", path.display());
-    let f = BufReader::new(File::open(path).unwrap());
-
     let scheduler = Arc::new(Scheduler::new(db, Config::default()));
     let loop_scheduler = scheduler.clone();
     let scheduler_loop_jh = std::thread::Builder::new()
         .name("moor-scheduler".to_string())
         .spawn(move || loop_scheduler.run())
         .unwrap();
 
-    let mut state = MootState::new(
+    execute_moot_test(
         SchedulerMootRunner::new(scheduler.clone(), Arc::new(NoopClientSession::new())),
-        WIZARD,
+        path,
     );
-    for (line_no, line) in f.lines().enumerate() {
-        state = state
-            .process_line(line_no + 1, &line.unwrap())
-            .context(format!("line {}", line_no + 1))
-            .unwrap();
-    }
-    state.finalize().unwrap();
 
     scheduler
         .submit_shutdown(0, Some("Test is done".to_string()))

crates/moot/Cargo.toml

@@ -14,5 +14,7 @@ description = "Execute MOO interaction tests described in simple text files."
 [dependencies]
 eyre.workspace = true
 pretty_assertions.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
 
 moor-values = { path = "../values" }

crates/moot/src/lib.rs

@@ -13,12 +13,15 @@
 //
 
 use std::{
+    collections::HashMap,
+    fs::File,
     io::{BufRead, BufReader, BufWriter, Write},
     net::TcpStream,
-    path::PathBuf,
+    path::{Path, PathBuf},
     process::Child,
+    sync::Once,
     thread,
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use eyre::WrapErr;
@@ -33,6 +36,24 @@ pub const PROGRAMMER: Objid = Objid(4);
 #[allow(dead_code)]
 pub const NONPROGRAMMER: Objid = Objid(5);
 
+#[allow(dead_code)]
+static LOGGING_INIT: Once = Once::new();
+#[allow(dead_code)]
+fn init_logging() {
+    LOGGING_INIT.call_once(|| {
+        let main_subscriber = tracing_subscriber::fmt()
+            .compact()
+            .with_ansi(true)
+            .with_file(true)
+            .with_line_number(true)
+            .with_thread_names(true)
+            .with_max_level(tracing::Level::WARN)
+            .with_test_writer()
+            .finish();
+        tracing::subscriber::set_global_default(main_subscriber)
+            .expect("Unable to set configure logging");
+    });
+}
 /// Look up the path to Test.db from any crate under the `moor` workspace
 pub fn test_db_path() -> PathBuf {
     PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../moot/Test.db")
@@ -360,6 +381,95 @@ impl MootClient {
             eprintln!("{} << {line}", self.port());
             lines.push(line.to_string());
         }
-        Ok(lines.join(""))
+        Ok(lines.join("\n"))
+    }
+}
+
+pub struct TelnetMootRunner {
+    port: u16,
+    clients: HashMap<Objid, MootClient>,
+}
+impl TelnetMootRunner {
+    pub fn new(port: u16) -> Self {
+        Self {
+            port,
+            clients: HashMap::new(),
+        }
+    }
+
+    fn client(&mut self, player: Objid) -> &mut MootClient {
+        self.clients.entry(player).or_insert_with(|| {
+            let start = Instant::now();
+            loop {
+                if let Ok(mut client) = MootClient::new(self.port) {
+                    client
+                        .send_string(std::format!("connect {}", player))
+                        .unwrap();
+                    return client;
+                } else if start.elapsed() > Duration::from_secs(5) {
+                    panic!("Failed to connect to daemon");
+                } else {
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+            }
+        })
+    }
+
+    fn resolve_response(&mut self, response: String) -> Result<String, std::io::Error> {
+        // Resolve the response; for example, the test assertion may be `$object`; resolve it to the object's specific number.
+        self.client(WIZARD).command(format!(
+            "; return {response}; \"TelnetMootRunner::resolve_response\";"
+        ))
+    }
+}
+impl MootRunner for TelnetMootRunner {
+    type Value = String;
+    type Error = std::io::Error;
+
+    fn eval<S: Into<String>>(
+        &mut self,
+        player: Objid,
+        command: S,
+    ) -> Result<String, std::io::Error> {
+        let response = self
+            .client(player)
+            .command(format!("; {} \"TelnetMootRunner::eval\";", command.into()))?;
+        self.resolve_response(response)
+    }
+
+    fn command<S: AsRef<str>>(
+        &mut self,
+        player: Objid,
+        command: S,
+    ) -> Result<String, std::io::Error> {
+        let response = self.client(player).command(command)?;
+        self.resolve_response(response)
+    }
+
+    fn none(&self) -> Self::Value {
+        "0".to_string()
+    }
+}
+
+pub fn execute_moot_test<R: MootRunner>(runner: R, path: &Path) {
+    init_logging();
+    eprintln!("Test definition: {}", path.display());
+
+    let f = BufReader::new(
+        File::open(path)
+            .wrap_err(format!("{}", path.display()))
+            .unwrap(),
+    );
+
+    let mut state = MootState::new(runner, WIZARD);
+    for (line_no, line) in f.lines().enumerate() {
+        let line = line.unwrap();
+        let line_no = line_no + 1;
+        state = state
+            .process_line(line_no, &line)
+            .wrap_err(format!("line {}", line_no))
+            .unwrap();
+        //eprintln!("[{line_no}] {line} {state:?}");
     }
+    state.finalize().unwrap();
 }