Experiment with futures

tests/file.rs

@@ -1,3 +1,4 @@
+use schematics::async_utils::run;
 use schematics::symbols::file::File as FileSymbol;
 use schematics::symbols::Symbol;
 use std::fs::File;
@@ -30,7 +31,9 @@ fn already_reached() {
   let dir = get_dir(Some("target content"));
   let symbol = get_symbol(dir.path());
 
-  assert_eq!(symbol.target_reached().unwrap(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.unwrap(), true);
+  })
 }
 
 // Bad
@@ -39,9 +42,11 @@ fn wrong_prefix() {
   let dir = get_dir(Some("not target content"));
   let symbol = get_symbol(dir.path());
 
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  symbol.execute().unwrap();
-  assert_eq!(symbol.target_reached().unwrap(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    symbol.execute().await.unwrap();
+    assert_eq!(symbol.target_reached().await.unwrap(), true);
+  })
 }
 
 #[test]
@@ -49,9 +54,11 @@ fn wrong_postfix() {
   let dir = get_dir(Some("target content not"));
   let symbol = get_symbol(dir.path());
 
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  symbol.execute().unwrap();
-  assert_eq!(symbol.target_reached().unwrap(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    symbol.execute().await.unwrap();
+    assert_eq!(symbol.target_reached().await.unwrap(), true);
+  })
 }
 
 #[test]
@@ -59,9 +66,11 @@ fn empty_file() {
   let dir = get_dir(Some(""));
   let symbol = get_symbol(dir.path());
 
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  symbol.execute().unwrap();
-  assert_eq!(symbol.target_reached().unwrap(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    symbol.execute().await.unwrap();
+    assert_eq!(symbol.target_reached().await.unwrap(), true);
+  })
 }
 
 #[test]
@@ -69,9 +78,11 @@ fn no_file() {
   let dir = get_dir(None);
   let symbol = get_symbol(dir.path());
 
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  symbol.execute().unwrap();
-  assert_eq!(symbol.target_reached().unwrap(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    symbol.execute().await.unwrap();
+    assert_eq!(symbol.target_reached().await.unwrap(), true);
+  })
 }
 
 // Exceptional cases
@@ -80,23 +91,29 @@ fn no_file() {
 fn may_not_read_file() {
   let symbol = FileSymbol::new(Path::new("/etc/shadow"), "");
 
-  assert_eq!(symbol.target_reached().is_err(), true);
+  run(async {
+    assert_eq!(symbol.target_reached().await.is_err(), true);
+  })
 }
 
 #[test]
 fn may_not_create_file() {
   let symbol = get_symbol(&Path::new("/proc/somefile"));
 
-  // Could also return an error
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  assert!(symbol.execute().is_err());
+  run(async {
+    // Could also return an error
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    assert!(symbol.execute().await.is_err());
+  })
 }
 
 #[test]
 fn directory_missing() {
   let symbol = get_symbol(&Path::new("/nonexisting"));
 
-  // Could also return an error
-  assert_eq!(symbol.target_reached().unwrap(), false);
-  assert!(symbol.execute().is_err());
+  run(async {
+    // Could also return an error
+    assert_eq!(symbol.target_reached().await.unwrap(), false);
+    assert!(symbol.execute().await.is_err());
+  })
 }

tests/setup.rs

@@ -1,34 +1,52 @@
-use schematics::resources::{Cert, Csr, GitCheckout};
-use schematics::schema::SymbolRunner;
+use async_trait::async_trait;
+use schematics::async_utils::sleep;
+use schematics::loggers::{Logger, StoringLogger};
+use schematics::resources::{AcmeUser, Cert, Csr, GitCheckout};
 use schematics::symbols::Symbol;
 use schematics::Setup;
+use schematics::SymbolRunner;
 use std::cell::RefCell;
 use std::error::Error;
 use std::fmt::Debug;
 use std::rc::Rc;
+use std::time::Duration;
 
+#[derive(Clone, Debug)]
 struct TestSymbolRunner {
   count: Rc<RefCell<usize>>,
 }
 
+#[async_trait(?Send)]
 impl SymbolRunner for TestSymbolRunner {
-  fn run_symbol<S: Symbol + Debug>(
+  async fn run_symbol<S: Symbol + Debug, L: Logger>(
     &self,
     _symbol: &S,
+    _logger: &L,
     _force: bool,
   ) -> Result<bool, Box<dyn Error>> {
     *self.count.borrow_mut() += 1;
+    sleep(Duration::from_millis(0)).await;
     Ok(false)
   }
 }
 
+#[test]
+fn can_create_an_acme_user() {
+  let count = Rc::new(RefCell::new(0));
+  let runner = TestSymbolRunner {
+    count: Rc::clone(&count),
+  };
+  let setup = Setup::new(runner, StoringLogger::new());
+  assert_eq!((setup.add(AcmeUser).unwrap().0).0, "acme");
+}
+
 #[test]
 fn runs_only_once() {
   let count = Rc::new(RefCell::new(0));
   let runner = TestSymbolRunner {
     count: Rc::clone(&count),
   };
-  let mut setup = Setup::new(runner);
+  let setup = Setup::new(runner, StoringLogger::new());
   assert_eq!(
     (setup.add(Csr("somehost")).unwrap().0)
       .as_ref()
@@ -52,7 +70,7 @@ fn can_create_an_acme_cert() {
   let runner = TestSymbolRunner {
     count: Rc::clone(&count),
   };
-  let mut setup = Setup::new(runner);
+  let setup = Setup::new(runner, StoringLogger::new());
   assert_eq!(
     (setup.add(Cert("somehost")).unwrap().0)
       .as_ref()
@@ -69,7 +87,7 @@ fn can_create_a_git_checkout() {
   let runner = TestSymbolRunner {
     count: Rc::clone(&count),
   };
-  let mut setup = Setup::new(runner);
+  let setup = Setup::new(runner, StoringLogger::new());
   setup
     .add(GitCheckout(
       "/tmp/somepath".into(),