cli-test: Update framework with new features

* Ability to switch between environments within the same test file
* Ability to expand env vars in `cd` command

radicle-cli-test/src/lib.rs

@@ -19,6 +19,8 @@ pub enum Error {
     Parse,
     #[error("invalid file path: {0:?}")]
     InvalidFilePath(String),
+    #[error("unknown home {0:?}")]
+    UnknownHome(String),
     #[error("test file not found: {0:?}")]
     TestNotFound(PathBuf),
     #[error("i/o: {0}")]
@@ -44,6 +46,8 @@ pub struct Test {
     stderr: bool,
     /// Whether to expect an error status code.
     fail: bool,
+    /// Home directory under which to run this test.
+    home: Option<String>,
     /// Local env vars to use just for this test.
     env: HashMap<String, String>,
 }
@@ -63,10 +67,92 @@ pub struct Assertion {
     exit: ExitStatus,
 }
 
+#[derive(Debug, Default, PartialEq, Eq, Clone)]
+pub struct Home {
+    name: Option<String>,
+    path: PathBuf,
+    envs: HashMap<String, String>,
+}
+
+#[derive(Debug)]
+pub struct TestRun {
+    home: Home,
+}
+
+impl TestRun {
+    fn cd(&mut self, path: PathBuf) {
+        self.home.path = path;
+    }
+
+    fn envs(&self) -> impl Iterator<Item = (&String, &String)> {
+        self.home.envs.iter()
+    }
+
+    fn path(&self) -> PathBuf {
+        self.home.path.clone()
+    }
+}
+
+#[derive(Debug)]
+pub struct TestRunner<'a> {
+    cwd: Option<PathBuf>,
+    homes: HashMap<String, Home>,
+    formula: &'a TestFormula,
+}
+
+impl<'a> TestRunner<'a> {
+    fn new(formula: &'a TestFormula) -> Self {
+        Self {
+            cwd: None,
+            homes: formula.homes.clone(),
+            formula,
+        }
+    }
+
+    fn run(&mut self, test: &'a Test) -> TestRun {
+        let mut envs = self.formula.env.clone();
+
+        if let Some(ref h) = test.home {
+            if let Some(home) = self.homes.get(h) {
+                envs.extend(home.envs.clone());
+                envs.extend(test.env.clone());
+
+                let home = Home {
+                    name: home.name.clone(),
+                    path: home.path.clone(),
+                    envs,
+                };
+                return TestRun { home };
+            } else {
+                panic!("TestRunner::test: home `~{h}` does not exist");
+            }
+        }
+        envs.extend(test.env.clone());
+
+        TestRun {
+            home: Home {
+                name: None,
+                path: self.cwd.clone().unwrap_or_else(|| self.formula.cwd.clone()),
+                envs,
+            },
+        }
+    }
+
+    fn finish(&mut self, run: TestRun) {
+        if let Some(name) = &run.home.name {
+            self.homes.insert(name.clone(), run.home);
+        } else {
+            self.cwd = Some(run.home.path);
+        }
+    }
+}
+
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct TestFormula {
     /// Current working directory to run the test in.
     cwd: PathBuf,
+    /// User homes.
+    homes: HashMap<String, Home>,
     /// Environment to pass to the test.
     env: HashMap<String, String>,
     /// Tests to run.
@@ -78,10 +164,11 @@ pub struct TestFormula {
 }
 
 impl TestFormula {
-    pub fn new() -> Self {
+    pub fn new(cwd: PathBuf) -> Self {
         Self {
-            cwd: PathBuf::new(),
+            cwd,
             env: HashMap::new(),
+            homes: HashMap::new(),
             tests: Vec::new(),
             subs: Substitutions::new(),
             bins: env::var("PATH")
@@ -140,13 +227,28 @@ impl TestFormula {
         self
     }
 
-    pub fn cwd(&mut self, path: impl AsRef<Path>) -> &mut Self {
+    pub fn env(&mut self, key: impl ToString, val: impl ToString) -> &mut Self {
-        self.cwd = path.as_ref().into();
+        self.env.insert(key.to_string(), val.to_string());
         self
     }
 
-    pub fn env(&mut self, key: impl Into<String>, val: impl Into<String>) -> &mut Self {
+    pub fn home(
-        self.env.insert(key.into(), val.into());
+        &mut self,
+        user: impl ToString,
+        path: impl AsRef<Path>,
+        envs: impl IntoIterator<Item = (impl ToString, impl ToString)>,
+    ) -> &mut Self {
+        self.homes.insert(
+            user.to_string(),
+            Home {
+                name: Some(user.to_string()),
+                path: path.as_ref().to_path_buf(),
+                envs: envs
+                    .into_iter()
+                    .map(|(k, v)| (k.to_string(), v.to_string()))
+                    .collect(),
+            },
+        );
         self
     }
 
@@ -198,22 +300,21 @@ impl TestFormula {
                     }
                 } else {
                     for token in line.split_whitespace() {
-                        if token.contains("stderr") {
+                        if let Some(home) = token.strip_prefix('~') {
+                            test.home = Some(home.to_owned());
+                        } else if let Some((key, val)) = token.split_once('=') {
+                            test.env.insert(key.to_owned(), val.to_owned());
+                        } else if token.contains("stderr") {
                             test.stderr = true;
-                        }
+                        } else if token.contains("fail") {
-                        if token.contains("fail") {
                             test.fail = true;
-                        }
+                        } else if let Some(path) = token.strip_prefix("./") {
-                        if let Some(path) = token.strip_prefix("./") {
                             file = Some((
                                 PathBuf::from_str(path)
                                     .map_err(|_| Error::InvalidFilePath(token.to_owned()))?,
                                 String::new(),
                             ));
                         }
-                        if let Some((key, val)) = token.split_once('=') {
-                            test.env.insert(key.to_owned(), val.to_owned());
-                        }
                     }
                 }
                 fenced = !fenced;
@@ -291,11 +392,16 @@ impl TestFormula {
 
     pub fn run(&mut self) -> Result<bool, io::Error> {
         let assert = Assert::new().substitutions(self.subs.clone());
+        let mut runner = TestRunner::new(self);
 
         fs::create_dir_all(&self.cwd)?;
         log::debug!(target: "test", "Using PATH {:?}", self.bins);
 
+        // For each code block.
         for test in &self.tests {
+            let mut run = runner.run(test);
+
+            // For each command.
             for assertion in &test.assertions {
                 let path = assertion
                     .path
@@ -305,28 +411,34 @@ impl TestFormula {
                 let cmd = if assertion.command == "rad" {
                     snapbox::cmd::cargo_bin("rad")
                 } else if assertion.command == "cd" {
-                    let path: PathBuf = assertion.args.first().unwrap().into();
+                    let mut arg = assertion.args.first().unwrap().clone();
-                    let path = self.cwd.join(path);
+                    for (k, v) in run.envs() {
+                        arg = arg.replace(&format!("${k}"), v);
+                    }
+                    let dir: PathBuf = arg.into();
+                    let dir = run.path().join(dir);
 
                     // TODO: Add support for `..` and `/`
                     // TODO: Error if more than one args are given.
 
-                    if !path.exists() {
+                    log::debug!(target: "test", "{path}: Running `cd {}`..", dir.display());
+
+                    if !dir.exists() {
                         return Err(io::Error::new(
                             io::ErrorKind::NotFound,
-                            format!("cd: '{}' does not exist", path.display()),
+                            format!("cd: '{}' does not exist", dir.display()),
                         ));
                     }
-                    self.cwd = path;
+                    run.cd(dir);
 
                     continue;
                 } else {
                     PathBuf::from(&assertion.command)
                 };
-                log::debug!(target: "test", "{path}: Running `{}` with {:?} in `{}`..", cmd.display(), assertion.args, self.cwd.display());
+                log::debug!(target: "test", "{path}: Running `{}` with {:?} in `{}`..", cmd.display(), assertion.args, run.path().display());
 
-                if !self.cwd.exists() {
+                if !run.path().exists() {
-                    log::error!(target: "test", "{path}: Directory {} does not exist..", self.cwd.display());
+                    log::error!(target: "test", "{path}: Directory {} does not exist..", run.path().display());
                 }
 
                 let bins = self
@@ -339,9 +451,8 @@ impl TestFormula {
                     .env_clear()
                     .env("PATH", &bins)
                     .env("RUST_BACKTRACE", "1")
-                    .envs(self.env.clone())
+                    .envs(run.envs())
-                    .envs(test.env.clone())
+                    .current_dir(run.path())
-                    .current_dir(&self.cwd)
                     .args(&assertion.args)
                     .with_assert(assert.clone())
                     .output();
@@ -376,6 +487,7 @@ impl TestFormula {
                     }
                 }
             }
+            runner.finish(run);
         }
         Ok(true)
     }
@@ -409,13 +521,14 @@ $ rad sync
         .as_bytes()
         .to_owned();
 
-        let mut actual = TestFormula::new();
+        let mut actual = TestFormula::new(PathBuf::new());
         let path = Path::new("test.md").to_path_buf();
         actual
             .read(path.as_path(), io::BufReader::new(io::Cursor::new(input)))
             .unwrap();
 
         let expected = TestFormula {
+            homes: HashMap::new(),
             cwd: PathBuf::new(),
             env: HashMap::new(),
             subs: Substitutions::new(),
@@ -427,6 +540,7 @@ $ rad sync
             tests: vec![
                 Test {
                     context: vec![String::from("Let's try to track @dave and @sean:")],
+                    home: None,
                     assertions: vec![
                         Assertion {
                             path: path.clone(),
@@ -453,6 +567,7 @@ $ rad sync
                 },
                 Test {
                     context: vec![String::from("Super, now let's move on to the next step.")],
+                    home: None,
                     assertions: vec![Assertion {
                         path: path.clone(),
                         command: String::from("rad"),
@@ -484,9 +599,8 @@ name = "radicle-cli-test"
         .as_bytes()
         .to_owned();
 
-        let mut formula = TestFormula::new();
+        let mut formula = TestFormula::new(PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap());
         formula
-            .cwd(env!("CARGO_MANIFEST_DIR"))
             .read(
                 Path::new("test.md"),
                 io::BufReader::new(io::Cursor::new(input)),
@@ -518,9 +632,8 @@ $ echo "[bug, good-first-issue]"
         .as_bytes()
         .to_owned();
 
-        let mut formula = TestFormula::new();
+        let mut formula = TestFormula::new(PathBuf::from_str(env!("CARGO_MANIFEST_DIR")).unwrap());
         formula
-            .cwd(env!("CARGO_MANIFEST_DIR"))
             .read(
                 Path::new("test.md"),
                 io::BufReader::new(io::Cursor::new(input)),

radicle-cli/examples/framework/home.md

@@ -0,0 +1,33 @@
+```
+$ mkdir bin
+$ cd bin
+$ touch file.bin
+```
+
+``` ~bob
+$ rad self --did
+did:key:z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk
+$ pwd
+[..]/home/bob/.radicle
+$ mkdir src
+$ cd src
+$ pwd
+[..]/home/bob/.radicle/src
+```
+
+``` ~alice
+$ rad self --did
+did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
+$ pwd
+[..]/home/alice/.radicle
+```
+
+``` ~bob
+$ pwd
+[..]/home/bob/.radicle/src
+```
+
+```
+$ ls
+file.bin
+```

radicle-cli/tests/commands.rs

@@ -28,7 +28,6 @@ fn test<'a>(
     home: Option<&Home>,
     envs: impl IntoIterator<Item = (&'a str, &'a str)>,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let base = Path::new(env!("CARGO_MANIFEST_DIR"));
     let tmp = tempfile::tempdir().unwrap();
     let home = if let Some(home) = home {
         home.path().to_path_buf()
@@ -36,14 +35,25 @@ fn test<'a>(
         tmp.path().to_path_buf()
     };
 
-    TestFormula::new()
+    formula(cwd.as_ref(), test)?
+        .env("RAD_HOME", home.to_string_lossy())
+        .envs(envs)
+        .run()?;
+
+    Ok(())
+}
+
+fn formula(root: &Path, test: impl AsRef<Path>) -> Result<TestFormula, Box<dyn std::error::Error>> {
+    let mut formula = TestFormula::new(root.to_path_buf());
+    let base = Path::new(env!("CARGO_MANIFEST_DIR"));
+
+    formula
         .env("GIT_AUTHOR_DATE", "1671125284")
         .env("GIT_AUTHOR_EMAIL", "radicle@localhost")
         .env("GIT_AUTHOR_NAME", "radicle")
         .env("GIT_COMMITTER_DATE", "1671125284")
         .env("GIT_COMMITTER_EMAIL", "radicle@localhost")
         .env("GIT_COMMITTER_NAME", "radicle")
-        .env("RAD_HOME", home.to_string_lossy())
         .env("RAD_PASSPHRASE", "radicle")
         .env("RAD_SEED", RAD_SEED)
         .env("EDITOR", "true")
@@ -52,16 +62,13 @@ fn test<'a>(
         .env("USER", "alice")
         .env(radicle_cob::git::RAD_COMMIT_TIME, "1671125284")
         .envs(git::env::GIT_DEFAULT_CONFIG)
-        .envs(envs)
-        .cwd(cwd)
         .build(&[
             ("radicle-remote-helper", "git-remote-rad"),
             ("radicle-cli", "rad"),
         ])
-        .file(base.join(test))?
+        .file(base.join(test))?;
-        .run()?;
 
-    Ok(())
+    Ok(formula)
 }
 
 #[test]
@@ -993,6 +1000,29 @@ fn rad_merge_after_update() {
     .unwrap();
 }
 
+fn framework_home() {
+    logger::init(log::Level::Debug);
+
+    let mut environment = Environment::new();
+    let alice = environment.node(Config::new(Alias::new("alice")));
+    let bob = environment.node(Config::new(Alias::new("bob")));
+
+    formula(&environment.tmp(), "examples/framework/home.md")
+        .unwrap()
+        .home(
+            "alice",
+            alice.home.path(),
+            [("RAD_HOME", alice.home.path().display())],
+        )
+        .home(
+            "bob",
+            bob.home.path(),
+            [("RAD_HOME", bob.home.path().display())],
+        )
+        .run()
+        .unwrap();
+}
+
 #[test]
 fn git_push_and_pull() {
     logger::init(log::Level::Debug);