//! 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(())

}