radicle-native-ci/tests/integration.rs

//! Integration tests for radicle-native-ci.
//!
//! Most of this module is helpers to make the actual tests easier to
//! express.
//!
//! These test the `radicle-ci-binary` by running it with different
//! inputs, and verifying the output is as expected.
//!
//! The binary is run with `cargo run -q`.
//!
//! Each can set up a configuration file for the adapter, a Radicle
//! node, and a git repository with a `.radicle/native.yaml` that runs
//! the appropriate shell command for the test case. Depending on the
//! test case, some or all of the previous may or may not happen.
//!
//! Each test case is represented by [`TestCase`], and those are built
//! with [`TestCaseBuilder`]. The builder pattern makes it easy to
//! vary what happens in each test case in a reasonably clear fashion.

use std::{
    collections::HashMap,
    fmt,
    fs::File,
    io::Write,
    path::{Path, PathBuf},
    process::Command,
    str::FromStr,
};

use radicle::{git::Oid, identity::Did, prelude::RepoId};
use radicle_ci_broker::msg::{
    Author, EventCommonFields, EventType, Patch, PatchEvent, Repository, Request, Response,
    RunResult, State,
};
use tempfile::{tempdir, TempDir};

use radicle_native_ci::{config::Config, runspec::RunSpec};

// Default timeout for CI runs. This is deliberately short to keep the
// time to run tests short.
const TIMEOUT: usize = 3;

// The result of running the adapter.
#[allow(dead_code)]
struct AdapterResult {
    exit: i32,
    stdout: String,
    stderr: String,
}

impl AdapterResult {
    // The messages that the adapter outputs, if parsing them is
    // possible.
    fn messages(&self) -> Result<Vec<Response>, serde_json::Error> {
        self.stdout
            .lines()
            .map(serde_json::from_str::<Response>)
            .collect()
    }

    // Assert that adapter stderr contains the wanted sub-string.
    fn assert_stderr_contains(&self, wanted: &str) {
        assert!(self.stderr.contains(wanted));
    }

    // Assert the adapter terminated with a specific exit code.
    fn assert_got_exit(&self, wanted: i32) {
        assert_eq!(self.exit, wanted);
    }

    // Assert that the adapter sent a message with a run ID.
    fn assert_got_run_id(&self) {
        let msgs = self.messages().unwrap();
        assert!(!msgs.is_empty());
        assert!(matches!(msgs[0], Response::Triggered { .. }));
    }

    // Assert that the adapter wrote a message indicating the CI run
    // succeeded.
    fn assert_got_success(&self) {
        let msgs = self.messages().unwrap();
        assert!(msgs.len() == 2);
        assert!(matches!(
            msgs[1],
            Response::Finished {
                result: RunResult::Success
            }
        ));
    }

    // Assert that the adapter wrote a message indicating the CI run
    // failed.
    fn assert_got_failure(&self) {
        let msgs = self.messages().unwrap();
        assert!(msgs.len() == 2);
        assert!(matches!(
            msgs[1],
            Response::Finished {
                result: RunResult::Failure
            }
        ));
    }
}

// Format an [`AdapterResult`] in a more readable way.
impl fmt::Debug for AdapterResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&format!(
            "AdapterResult:\n  exit: {}\n  stdout:\n{}  stderr:\n{}",
            self.exit,
            indent(&self.stdout),
            indent(&self.stderr),
        ))
    }
}

// Indent every line in a string.
fn indent(s: &str) -> String {
    let mut out = String::new();
    for line in s.lines() {
        out.push_str(&format!("    {line:?}\n"));
    }
    out
}

// All the information needed to run the adapter for a specific test
// case. Constructed by [`TestCaseBuilder::build`].
struct TestCase {
    tmp: TempDir,
    envs: HashMap<String, String>,
    git: Git,
    rad: Rad,
    request: TriggerKind,
}

impl TestCase {
    fn run(&self) -> Result<AdapterResult, std::io::Error> {
        println!("run adapter");

        let tmp = self.tmp.path().to_path_buf();

        // Create a request and write it to a file, if requested. The
        // file is always created so that it can be the adapter's
        // stdin.
        let req_filename = tmp.join("request.json");
        let mut req_file = File::create(&req_filename)?;
        match self.request {
            TriggerKind::Empty => {}
            TriggerKind::Trigger => {
                let commit = self.git.head()?;
                self.rad.init(self.git.path())?;
                let rid = self.rad.rid(self.git.path())?;
                let req = trigger(rid, commit);
                let mut line = serde_json::to_string(&req).unwrap();
                line.push('\n');
                req_file.write_all(line.as_bytes())?;
            }
            TriggerKind::MissingRepo => {
                let commit = Oid::from_str("54aacc96197a48b79fcc260f94312d824f5e0a34").unwrap();
                let rid = RepoId::from_str("rad:z3qg5TKmN83afz2fj9z3fQjU8vaYE").unwrap();
                let req = trigger(rid, commit);
                let mut line = serde_json::to_string(&req).unwrap();
                line.push('\n');
                req_file.write_all(line.as_bytes())?;
            }
            TriggerKind::MissingCommit => {
                let commit = Oid::from_str("54aacc96197a48b79fcc260f94312d824f5e0a34").unwrap();
                self.rad.init(self.git.path())?;
                let rid = self.rad.rid(self.git.path())?;
                let req = trigger(rid, commit);
                let mut line = serde_json::to_string(&req).unwrap();
                line.push('\n');
                req_file.write_all(line.as_bytes())?;
            }
        }

        println!("run adapter with cargo run");
        let adapter = Command::new("cargo")
            .args(["run", "-q"])
            .envs(self.envs.iter())
            .stdin(File::open(&req_filename)?)
            .output()?;
        let result = AdapterResult {
            exit: adapter.status.code().unwrap(),
            stdout: String::from_utf8_lossy(&adapter.stdout).into(),
            stderr: String::from_utf8_lossy(&adapter.stderr).into(),
        };
        println!("{result:#?}");
        Ok(result)
    }
}

// What kind of config should the adapter be provided?
enum ConfigKind {
    // No config: do not set RADICLE_NATIVE_CI in the environment.
    UnsetEnvVar,

    // No config: file does not exist.
    DoesNotExist(PathBuf),

    // No config: file is empty.
    EmptyConfig(PathBuf),

    // Valid config.
    Valid(PathBuf),
}

// What kind of trigger message should we give the adapter?
enum TriggerKind {
    // Broken: an empty input.
    Empty,

    // Broken: the repository referred to doesn't exist.
    MissingRepo,

    // Broken: the commit referred to doesn't exist in the repo.
    MissingCommit,

    // Valid Trigger message.
    Trigger,
}

// Build a new [`TestCase`].
//
// Before `build` is called, a config and a request must be chosen.
// The shell command to run is optional, and defaults to an empty
// command.
struct TestCaseBuilder {
    tmp: TempDir,
    config: Option<ConfigKind>,
    request: Option<TriggerKind>,
    shell: String,
}

impl TestCaseBuilder {
    fn new() -> Result<Self, std::io::Error> {
        // Create a temporary directory for all files for this test
        // case. When the test case is dropped, the directory and all
        // its contents are deleted.
        let tmp = tempdir()?;

        Ok(Self {
            tmp,
            config: None,
            request: None,
            shell: "".into(),
        })
    }

    fn without_config(mut self) -> Self {
        self.config = Some(ConfigKind::UnsetEnvVar);
        self
    }

    fn with_empty_config(mut self) -> Self {
        self.config = Some(ConfigKind::EmptyConfig(PathBuf::from("/dev/null")));
        self
    }

    fn with_nonexistent_config(mut self) -> Self {
        self.config = Some(ConfigKind::DoesNotExist(
            self.tmp.path().join("does-not-exist.yaml"),
        ));
        self
    }

    fn with_config(mut self) -> Self {
        self.config = Some(ConfigKind::Valid(self.tmp.path().join("config.yaml")));
        self
    }

    fn with_empty_request(mut self) -> Self {
        self.request = Some(TriggerKind::Empty);
        self
    }

    fn with_request_for_nonexistent_repo(mut self) -> Self {
        self.request = Some(TriggerKind::MissingRepo);
        self
    }

    fn with_request_for_nonexistent_commit(mut self) -> Self {
        self.request = Some(TriggerKind::MissingCommit);
        self
    }

    fn with_request(mut self) -> Self {
        self.request = Some(TriggerKind::Trigger);
        self
    }

    fn with_shell(mut self, shell: &str) -> Self {
        self.shell = shell.into();
        self
    }

    fn build(self) -> Result<TestCase, std::io::Error> {
        let tmp = self.tmp.path();

        // Create a Radicle node.
        let rad = Rad::new(&tmp.join("dot-radicle"))?;
        rad.auth()?;

        // Create a git repository.
        let path = tmp.join("git");
        let git = Git::new(&path)?;
        git.init()?;
        git.write("README.md", "Test README")?;

        // Add .radicle/native.yaml.
        let runspec = RunSpec { shell: self.shell };
        std::fs::create_dir(git.path().join(".radicle"))?;
        git.write(
            ".radicle/native.yaml",
            &serde_yaml::to_string(&runspec).unwrap(),
        )?;

        // Commit everything.
        git.commit("first commit")?;

        // Create a native CI adapter config.
        assert!(self.config.is_some());
        let config = self.config.unwrap();
        if let ConfigKind::Valid(filename) = &config {
            let config = Config {
                state: tmp.join("state"),
                log: tmp.join("log.html"),
                timeout: Some(TIMEOUT),
            };
            let config = serde_yaml::to_string(&config).unwrap();
            std::fs::write(filename, config)?;
        }

        // Set up the requested environment with RAD_HOME and
        // RAD_PASSPHRASE set to the right values.
        let mut envs = HashMap::new();
        envs.insert("RAD_HOME".into(), format!("{}", rad.home().display()));
        envs.insert("RAD_PASSPHRASE".into(), Rad::PASSPHRASE.into());

        // Set RADICLE_NATIVE_CI if it should be set.
        match config {
            ConfigKind::UnsetEnvVar => (),
            ConfigKind::DoesNotExist(filename)
            | ConfigKind::EmptyConfig(filename)
            | ConfigKind::Valid(filename) => {
                envs.insert("RADICLE_NATIVE_CI".into(), filename.display().to_string());
            }
        }

        assert!(self.request.is_some());
        Ok(TestCase {
            tmp: self.tmp,
            envs,
            git,
            rad,
            request: self.request.unwrap(),
        })
    }
}

// Manage a git repository for test purposes.
struct Git {
    path: PathBuf,
}

impl Git {
    fn new(path: &Path) -> Result<Self, std::io::Error> {
        println!("create git repository at {}", path.display());
        std::fs::create_dir(path)?;
        Ok(Self { path: path.into() })
    }

    fn path(&self) -> &Path {
        &self.path
    }

    fn write(&self, relative: &str, content: &str) -> Result<(), std::io::Error> {
        println!("write to file {relative} content {content:?}");
        std::fs::write(self.path.join(relative), content)?;
        Ok(())
    }

    fn _git(&self, args: &[&str]) -> Result<String, std::io::Error> {
        println!("run git {args:?} in {}", self.path.display());

        let output = Command::new("git")
            .current_dir(&self.path)
            .args(args)
            .output()?;

        let exit = output.status.code().unwrap();
        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        println!("  exit: {}", exit);
        println!("  stdout: {:?}", stdout);
        println!("  stderr: {:?}", stderr);

        assert_eq!(exit, 0);
        Ok(stdout)
    }

    fn init(&self) -> Result<(), std::io::Error> {
        self._git(&["init", "."])?;
        Ok(())
    }

    fn commit(&self, msg: &str) -> Result<(), std::io::Error> {
        self._git(&["add", "."])?;
        self._git(&["commit", "-m", msg])?;
        Ok(())
    }

    fn head(&self) -> Result<Oid, std::io::Error> {
        let commit = self._git(&["rev-parse", "HEAD"])?;
        let commit = Oid::from_str(commit.trim()).unwrap();
        Ok(commit)
    }
}

// Manage a Radicle node with `rad` for test purposes. This sets up a
// new node for the test, it does not use the default node on the host.
struct Rad {
    home: PathBuf,
}

impl Rad {
    const PASSPHRASE: &'static str = "xyzzy";

    fn new(home: &Path) -> Result<Self, std::io::Error> {
        std::fs::create_dir(home)?;
        Ok(Self { home: home.into() })
    }

    fn home(&self) -> &Path {
        &self.home
    }

    fn _rad(&self, args: &[&str], cwd: &Path) -> Result<String, std::io::Error> {
        println!("run rad {args:?} in {}", cwd.display());

        let output = Command::new("rad")
            .current_dir(cwd)
            .args(args)
            .env("RAD_HOME", self.home.display().to_string())
            .env("RAD_PASSPHRASE", Self::PASSPHRASE)
            .output()?;

        let exit = output.status.code().unwrap();
        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        println!("  exit: {}", exit);
        println!("  stdout: {:?}", stdout);
        println!("  stderr: {:?}", stderr);

        assert_eq!(exit, 0);
        Ok(stdout)
    }

    fn auth(&self) -> Result<(), std::io::Error> {
        self._rad(&["auth", "--alias=test-node"], &self.home)?;
        Ok(())
    }

    fn init(&self, git_dir: &Path) -> Result<(), std::io::Error> {
        let name = format!("{}", Path::new(git_dir.file_stem().unwrap()).display());
        self._rad(
            &[
                "init",
                "--name",
                &name,
                "--description=test repo",
                "--public",
                "--no-confirm",
            ],
            git_dir,
        )?;
        Ok(())
    }

    fn rid(&self, git_dir: &Path) -> Result<RepoId, std::io::Error> {
        let rid = self._rad(&["."], git_dir)?;
        let rid = RepoId::from_str(rid.trim()).unwrap();
        Ok(rid)
    }
}

// Construct a trigger message for test purposes.
fn trigger(repo_id: RepoId, commit: Oid) -> Request {
    Request::Trigger {
        common: EventCommonFields {
            event_type: EventType::Push,
            repository: Repository {
                id: repo_id,
                name: "test-repo".into(),
                description: "test repo".into(),
                private: false,
                default_branch: "main".into(),
                delegates: vec![],
            },
        },
        push: None,
        patch: Some(PatchEvent {
            action: "updated".into(),
            patch: Patch {
                id: Oid::try_from("ff3099ba5de28d954c41d0b5a84316f943794ea4").unwrap(),
                author: Author {
                    id: Did::decode("did:key:z6MkgEMYod7Hxfy9qCvDv5hYHkZ4ciWmLFgfvm3Wn1b2w2FV")
                        .unwrap(),
                    alias: None,
                },
                title: "title".into(),
                state: State {
                    status: "status".into(),
                    conflicts: vec![],
                },
                before: commit,
                after: commit,
                commits: vec![commit],
                target: Oid::try_from("244130556b47dbc83323ad8e0c2b53c491e6b925").unwrap(),
                labels: vec![],
                assignees: vec![],
                revisions: vec![],
            },
        }),
    }
}

type TestResult = Result<(), std::io::Error>;

// What does the adapter do if the RADICLE_NATIVE_CI environment
// variable is not set?
#[test]
fn no_config_env_var() -> TestResult {
    let result = TestCaseBuilder::new()?
        .without_config()
        .with_empty_request()
        .build()?
        .run()?;
    result.assert_got_exit(2);
    result.assert_stderr_contains("RADICLE_NATIVE_CI");
    Ok(())
}

// What does the adapter do if its configuration file does not exist?
#[test]
fn config_does_not_exist() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_nonexistent_config()
        .with_empty_request()
        .build()?
        .run()?;
    result.assert_got_exit(2);
    result.assert_stderr_contains("failed to read configuration file");
    result.assert_stderr_contains("No such file or directory");
    Ok(())
}

// What does the adapter do if its configuration file is empty?
#[test]
fn empty_config() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_empty_config()
        .with_empty_request()
        .build()?
        .run()?;

    result.assert_got_exit(2);
    result.assert_stderr_contains("YAML");
    Ok(())
}

// What does the adapter do if its stdin is empty and does not have a
// request message?
#[test]
fn empty_request() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_empty_request()
        .build()?
        .run()?;

    result.assert_got_exit(2);
    result.assert_stderr_contains("read request from stdin");
    result.assert_stderr_contains("JSON");
    Ok(())
}

// What does the adapter do if CI runs a command that fails?
#[test]
fn command_fails() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_request()
        .with_shell("false")
        .build()?
        .run()?;

    result.assert_got_exit(1);
    result.assert_got_run_id();
    result.assert_got_failure();
    Ok(())
}

// What does the adapter do if it's triggered to run for a repository
// that doesn't exist?
#[test]
fn repo_doesnt_exist() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_request_for_nonexistent_repo()
        .with_shell("false")
        .build()?
        .run()?;

    result.assert_got_exit(1);
    result.assert_got_run_id();
    result.assert_got_failure();
    Ok(())
}

// What does the adapter do if it's triggered to run for a commit that
// does not exist in the repository it's running on?
#[test]
fn commit_doesnt_exist() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_request_for_nonexistent_commit()
        .with_shell("false")
        .build()?
        .run()?;

    result.assert_got_exit(1);
    result.assert_got_run_id();
    result.assert_got_failure();
    Ok(())
}

// What does the adapter do if the commands its running take too long?
#[test]
fn command_takes_too_long() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_request_for_nonexistent_commit()
        .with_shell(&format!("sleep {}", TIMEOUT + 2))
        .build()?
        .run()?;

    result.assert_got_exit(1);
    result.assert_got_run_id();
    result.assert_got_failure();
    Ok(())
}

// What does the adapter do if everything goes well?
#[test]
fn happy_path() -> TestResult {
    let result = TestCaseBuilder::new()?
        .with_config()
        .with_request()
        .with_shell("echo hello, world")
        .build()?
        .run()?;

    result.assert_got_exit(0);
    result.assert_got_run_id();
    result.assert_got_success();
    Ok(())
}