// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use suite_definition::TestParamsOptions;

mod output_directory;
mod suite_definition;

use {
    anyhow::{anyhow, format_err, Context, Result},
    errors::{ffx_bail, ffx_bail_with_code, ffx_error, ffx_error_with_code, FfxError},
    ffx_core::ffx_plugin,
    ffx_test_args::{
        DeleteResultCommand, ListCommand, ResultCommand, ResultSubCommand, RunCommand,
        ShowResultCommand, TestCommand, TestSubcommand,
    },
    fidl::endpoints::create_proxy,
    fidl::endpoints::ProtocolMarker,
    fidl_fuchsia_developer_remotecontrol as fremotecontrol,
    fidl_fuchsia_test_manager as ftest_manager,
    ftest_manager::{RunBuilderMarker, RunBuilderProxy},
    futures::FutureExt,
    lazy_static::lazy_static,
    output_directory::{DirectoryError, DirectoryId, DirectoryManager},
    selectors::{self, VerboseError},
    signal_hook::{
        consts::signal::{SIGINT, SIGTERM},
        iterator::Signals,
    },
    std::io::{stdout, Write},
    std::path::PathBuf,
};

const RUN_BUILDER_SELECTOR: &str = "core/test_manager:expose:fuchsia.test.manager.RunBuilder";

lazy_static! {
    /// Error code returned if connecting to Test Manager fails.
    static ref SETUP_FAILED_CODE: i32 = -fidl::Status::UNAVAILABLE.into_raw();
    /// Error code returned if tests time out.
    static ref TIMED_OUT_CODE: i32 = -fidl::Status::TIMED_OUT.into_raw();
}

struct RunBuilderConnector {
    remote_control: fremotecontrol::RemoteControlProxy,
}

impl RunBuilderConnector {
    async fn connect(&self) -> RunBuilderProxy {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<RunBuilderMarker>()
            .expect(&format!("failed to create proxy to {}", RunBuilderMarker::DEBUG_NAME));
        self.remote_control
            .connect(
                selectors::parse_selector::<VerboseError>(RUN_BUILDER_SELECTOR)
                    .expect("cannot parse run builder selector"),
                server_end.into_channel(),
            )
            .await
            .expect("Failed to send connect request")
            .expect(&format!(
                "failed to connect to {} as {}",
                RunBuilderMarker::DEBUG_NAME,
                RUN_BUILDER_SELECTOR
            ));
        proxy
    }

    fn new(remote_control: fremotecontrol::RemoteControlProxy) -> Box<Self> {
        Box::new(Self { remote_control })
    }
}

#[ffx_plugin(ftest_manager::QueryProxy = "core/test_manager:expose:fuchsia.test.manager.Query")]
pub async fn test(
    query_proxy_result: Result<ftest_manager::QueryProxy>,
    remote_control_result: Result<fremotecontrol::RemoteControlProxy>,
    cmd: TestCommand,
) -> Result<()> {
    let writer = Box::new(stdout());

    let query_proxy =
        query_proxy_result.map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;
    let remote_control =
        remote_control_result.map_err(|e| ffx_error_with_code!(*SETUP_FAILED_CODE, "{:?}", e))?;

    match cmd.subcommand {
        TestSubcommand::Run(run) => {
            run_test(RunBuilderConnector::new(remote_control), writer, run).await
        }
        TestSubcommand::List(list) => get_tests(query_proxy, writer, list).await,
        TestSubcommand::Result(result) => result_command(result, writer).await,
    }
}

async fn get_directory_manager() -> Result<DirectoryManager> {
    let output_path_config: PathBuf = match ffx_config::get("test.output_path").await? {
        Some(output_path) => output_path,
        None => ffx_bail!(
            "Could not find the test output path configuration. Please run \
            `ffx config set test.output_path \"<PATH>\" to configure the location."
        ),
    };
    let save_count_config: usize = ffx_config::get("test.save_count").await?;
    Ok(DirectoryManager::new(output_path_config, save_count_config)?)
}

async fn run_test<W: 'static + Write + Send + Sync>(
    builder_connector: Box<RunBuilderConnector>,
    writer: W,
    cmd: RunCommand,
) -> Result<()> {
    // Whether or not the experimental structured output is enabled.
    // When the experiment is disabled and the user attempts to use a strucutured output option,
    // we bail.
    let structured_output_experiment =
        match ffx_config::get("test.experimental_structured_output").await {
            Ok(true) => true,
            Ok(false) | Err(_) => false,
        };
    let output_directory =
        match (cmd.disable_output_directory, &cmd.output_directory, structured_output_experiment) {
            (true, _, _) => None, // user explicitly disabled output.
            (false, Some(directory), true) => Some(directory.clone().into()), // an override directory is specified.
            // user specified an override, but output is disabled by experiment flag.
            (false, Some(_), false) => {
                ffx_bail!(
                    "Structured output is experimental and is subject to breaking changes. \
                To enable structured output run \
                'ffx config set test.experimental_structured_output true'"
                )
            }
            // Default to a managed directory when structured output is enabled.
            (false, None, true) => {
                let mut directory_manager = get_directory_manager().await?;
                Some(directory_manager.new_directory()?)
            }
            // Default to nothing when structured output is disabled.
            (false, None, false) => None,
        };

    let min_log_severity = cmd.min_severity_logs;
    let filter_ansi = cmd.filter_ansi;

    let json_input_experiment = match ffx_config::get("test.experimental_json_input").await {
        Ok(true) => true,
        Ok(false) | Err(_) => false,
    };
    let run_params = run_test_suite_lib::RunParams {
        timeout_behavior: match cmd.continue_on_timeout {
            false => run_test_suite_lib::TimeoutBehavior::TerminateRemaining,
            true => run_test_suite_lib::TimeoutBehavior::Continue,
        },
        stop_after_failures: match cmd.stop_after_failures.map(std::num::NonZeroU32::new) {
            None => None,
            Some(None) => ffx_bail!("--stop-after-failures should be greater than zero."),
            Some(Some(stop_after)) => Some(stop_after),
        },
    };
    let test_definitions = test_params_from_args(cmd, std::io::stdin, json_input_experiment)?;

    let (cancel_sender, cancel_receiver) = futures::channel::oneshot::channel::<()>();
    let mut signals = Signals::new(&[SIGINT, SIGTERM]).unwrap();
    // signals.forever() is blocking, so we need to spawn a thread rather than use async.
    let _signal_handle_thread = std::thread::spawn(move || {
        for signal in signals.forever() {
            match signal {
                SIGINT | SIGTERM => {
                    let _ = cancel_sender.send(());
                    break;
                }
                _ => unreachable!(),
            }
        }
    });
    let reporter = create_reporter(filter_ansi, output_directory, writer)?;
    match run_test_suite_lib::run_tests_and_get_outcome(
        builder_connector.connect().await,
        test_definitions,
        run_params,
        min_log_severity,
        reporter,
        cancel_receiver.map(|_| ()),
    )
    .await
    {
        run_test_suite_lib::Outcome::Passed => Ok(()),
        run_test_suite_lib::Outcome::Timedout => {
            ffx_bail_with_code!(*TIMED_OUT_CODE, "Tests timed out.",)
        }
        run_test_suite_lib::Outcome::Failed | run_test_suite_lib::Outcome::DidNotFinish => {
            ffx_bail!("Tests failed.")
        }
        run_test_suite_lib::Outcome::Cancelled => ffx_bail!("Tests cancelled."),
        run_test_suite_lib::Outcome::Inconclusive => ffx_bail!("Inconclusive test result."),
        run_test_suite_lib::Outcome::Error { origin } => match origin.is_internal_error() {
            // Using anyhow instead of ffx_bail here prints a message to file a bug.
            true => Err(anyhow!("There was an internal error running tests: {:?}", origin)),
            false => ffx_bail!("There was an error running tests: {:?}", origin),
        },
    }
}

/// Generate TestParams from |cmd|.
/// |stdin_handle_fn| is a function that generates a handle to stdin and is a parameter to enable
/// testing.
fn test_params_from_args<F, R>(
    cmd: RunCommand,
    stdin_handle_fn: F,
    json_input_experiment_enabled: bool,
) -> Result<Vec<run_test_suite_lib::TestParams>, FfxError>
where
    F: Fn() -> R,
    R: std::io::Read,
{
    match &cmd.test_file {
        Some(_) if !json_input_experiment_enabled => {
            return Err(ffx_error!(
                "The --test-file option is experimental, and the input format is \
                subject to breaking changes. To enable using --test-file, run \
                'ffx config set test.experimental_json_input true'"
            ))
        }
        Some(filename) => {
            if !cmd.test_args.is_empty() {
                return Err(ffx_error!("Tests may not be specified in both args and by file"));
            }
            if filename == "-" {
                suite_definition::test_params_from_reader(
                    stdin_handle_fn(),
                    TestParamsOptions { ignore_test_without_known_execution: false },
                )
                .map_err(|e| ffx_error!("Failed to read test definitions: {:?}", e))
            } else {
                let file = std::fs::File::open(filename)
                    .map_err(|e| ffx_error!("Failed to open file {}: {:?}", filename, e))?;
                suite_definition::test_params_from_reader(
                    file,
                    TestParamsOptions { ignore_test_without_known_execution: false },
                )
                .map_err(|e| ffx_error!("Failed to read test definitions: {:?}", e))
            }
        }
        None => {
            let mut test_args_iter = cmd.test_args.iter();
            let (test_url, test_args) = match test_args_iter.next() {
                None => return Err(ffx_error!("No tests specified!")),
                Some(test_url) => {
                    (test_url.clone(), test_args_iter.map(String::clone).collect::<Vec<_>>())
                }
            };

            let count = cmd.count.unwrap_or(1);
            let count = std::num::NonZeroU32::new(count)
                .ok_or_else(|| ffx_error!("--count should be greater than zero."))?;
            Ok(vec![
                run_test_suite_lib::TestParams {
                    test_url,
                    timeout_seconds: cmd.timeout.and_then(std::num::NonZeroU32::new),
                    test_filters: if cmd.test_filter.len() == 0 {
                        None
                    } else {
                        Some(cmd.test_filter)
                    },
                    max_severity_logs: cmd.max_severity_logs,
                    also_run_disabled_tests: cmd.run_disabled,
                    parallel: cmd.parallel,
                    test_args,
                    tags: vec![],
                };
                count.get() as usize
            ])
        }
    }
}

fn create_reporter<W: 'static + Write + Send + Sync>(
    filter_ansi: bool,
    dir: Option<PathBuf>,
    writer: W,
) -> Result<run_test_suite_lib::output::RunReporter> {
    let stdout_reporter = run_test_suite_lib::output::ShellReporter::new(writer);
    let dir_reporter =
        dir.map(run_test_suite_lib::output::DirectoryWithStdoutReporter::new).transpose()?;
    let reporter = match (dir_reporter, filter_ansi) {
        (Some(dir_reporter), false) => run_test_suite_lib::output::RunReporter::new(
            run_test_suite_lib::output::MultiplexedReporter::new(stdout_reporter, dir_reporter),
        ),
        (Some(dir_reporter), true) => run_test_suite_lib::output::RunReporter::new_ansi_filtered(
            run_test_suite_lib::output::MultiplexedReporter::new(stdout_reporter, dir_reporter),
        ),
        (None, false) => run_test_suite_lib::output::RunReporter::new(stdout_reporter),
        (None, true) => run_test_suite_lib::output::RunReporter::new_ansi_filtered(stdout_reporter),
    };
    Ok(reporter)
}

async fn get_tests<W: Write>(
    query_proxy: ftest_manager::QueryProxy,
    mut write: W,
    cmd: ListCommand,
) -> Result<()> {
    let writer = &mut write;
    let (iterator_proxy, iterator) = create_proxy().unwrap();

    log::info!("launching test suite {}", cmd.test_url);

    query_proxy
        .enumerate(&cmd.test_url, iterator)
        .await
        .context("enumeration failed")?
        .map_err(|e| format_err!("error launching test: {:?}", e))?;

    loop {
        let cases = iterator_proxy.get_next().await?;
        if cases.is_empty() {
            return Ok(());
        }
        writeln!(writer, "Tests in suite {}:\n", cmd.test_url)?;
        for case in cases {
            match case.name {
                Some(n) => writeln!(writer, "{}", n)?,
                None => writeln!(writer, "<No name>")?,
            }
        }
    }
}

async fn result_command<W: Write>(
    ResultCommand { subcommand }: ResultCommand,
    mut writer: W,
) -> Result<()> {
    match ffx_config::get("test.experimental_structured_output").await {
        Ok(true) => (),
        Ok(false) | Err(_) => ffx_bail!(
            "The result subcommand relies on structured output, which is experimental \
            and subject to breaking changes. \
            To enable structured output run 'ffx config set test.experimental_structured_output true'
        ")
    }

    match subcommand {
        ResultSubCommand::Show(ShowResultCommand { directory, index, name }) => {
            let directory_to_display = if let Some(directory_override) = directory {
                Some(directory_override.into())
            } else if let Some(specified_index) = index {
                get_directory_manager().await?.get_by_id(DirectoryId::Index(specified_index))?
            } else if let Some(specified_name) = name {
                get_directory_manager().await?.get_by_id(DirectoryId::Name(specified_name))?
            } else {
                get_directory_manager().await?.latest_directory()?
            };
            match directory_to_display {
                Some(dir) => display_output_directory(dir, writer),
                None => {
                    writeln!(writer, "Directory not found")?;
                    Ok(())
                }
            }
        }
        ResultSubCommand::List(_) => result_list_command(writer).await,
        ResultSubCommand::Delete(delete) => result_delete_command(delete, writer).await,
        ResultSubCommand::Save(save) => {
            get_directory_manager().await?.save_directory(save.index, save.name)?;
            Ok(())
        }
    }
}

async fn result_list_command<W: Write>(mut writer: W) -> Result<()> {
    let entries = get_directory_manager().await?.entries_ordered()?;
    let unsaved_entries = entries
        .iter()
        .filter_map(|(id, entry)| match id {
            DirectoryId::Index(index) => Some((index, entry.timestamp)),
            DirectoryId::Name(_) => None,
        })
        .collect::<Vec<_>>();
    if unsaved_entries.len() > 0 {
        writeln!(writer, "Found run results:")?;
        for (id, maybe_timestamp) in unsaved_entries {
            match maybe_timestamp {
                Some(timestamp) => {
                    let local_time: chrono::DateTime<chrono::Local> = timestamp.into();
                    writeln!(writer, "{}: {}", id, local_time.to_rfc2822())?
                }
                None => writeln!(writer, "{}", id)?,
            }
        }
    }

    let saved_entries = entries
        .iter()
        .filter_map(|(id, entry)| match id {
            DirectoryId::Index(_) => None,
            DirectoryId::Name(name) => Some((name, entry.timestamp)),
        })
        .collect::<Vec<_>>();
    if saved_entries.len() > 0 {
        writeln!(writer, "Saved run results:")?;
        for (name, maybe_timestamp) in saved_entries {
            match maybe_timestamp {
                Some(timestamp) => {
                    let local_time: chrono::DateTime<chrono::Local> = timestamp.into();
                    writeln!(writer, "{}: {}", name, local_time.to_rfc2822())?
                }
                None => writeln!(writer, "{}", name)?,
            }
        }
    }
    Ok(())
}

fn display_output_directory<W: Write>(path: PathBuf, mut writer: W) -> Result<()> {
    let test_output_directory::TestRunResult { common: run_common, suites, .. } =
        test_output_directory::TestRunResult::from_dir(&path)?;
    let run_common = run_common.into_owned();

    writeln!(writer, "Run result: {:?}", run_common.outcome)?;
    let run_artifacts = run_common.artifact_dir.contents();
    if run_artifacts.len() > 0 {
        writeln!(
            writer,
            "Run artifacts: {}",
            run_artifacts.iter().map(|path| path.to_string_lossy()).collect::<Vec<_>>().join(", ")
        )?;
    }

    for suite in suites {
        let test_output_directory::SuiteResult { common: suite_common, cases, .. } = suite;
        let suite_common = suite_common.into_owned();
        writeln!(writer, "Suite {} result: {:?}", suite_common.name, suite_common.outcome)?;
        let artifacts = suite_common.artifact_dir.contents();
        if artifacts.len() > 0 {
            writeln!(
                writer,
                "\tArtifacts: {}",
                artifacts.iter().map(|path| path.to_string_lossy()).collect::<Vec<_>>().join(", ")
            )?;
        }
        for case in cases {
            let case_common = case.common.into_owned();
            writeln!(writer, "\tCase '{}' result: {:?}", case_common.name, case_common.outcome)?;
            let artifacts = case_common.artifact_dir.contents();
            if artifacts.len() > 0 {
                writeln!(
                    writer,
                    "\tCase {} Artifacts: {}",
                    case_common.name,
                    artifacts
                        .iter()
                        .map(|path| path.to_string_lossy())
                        .collect::<Vec<_>>()
                        .join(", ")
                )?;
            }
        }
    }

    Ok(())
}

async fn result_delete_command<W: Write>(
    DeleteResultCommand { index, name }: DeleteResultCommand,
    mut writer: W,
) -> Result<()> {
    let id = match (index, name) {
        (Some(_), Some(_)) => {
            writeln!(writer, "Cannot specify both index and name.")?;
            return Ok(());
        }
        (Some(index), None) => DirectoryId::Index(index),
        (None, Some(name)) => DirectoryId::Name(name),
        (None, None) => {
            writeln!(writer, "No directory specified.")?;
            return Ok(());
        }
    };
    match get_directory_manager().await?.delete(id) {
        Ok(()) => {
            writeln!(writer, "Deleted a run result.")?;
            Ok(())
        }
        Err(DirectoryError::IdNotFound(_)) => {
            writeln!(writer, "Directory not found")?;
            Ok(())
        }
        Err(e) => Err(e.into()),
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use lazy_static::lazy_static;
    use std::num::NonZeroU32;
    use test_list::TestTag;

    const VALID_INPUT_FILENAME: &str = "valid_defs.json";
    const INVALID_INPUT_FILENAME: &str = "invalid_defs.json";

    lazy_static! {
        static ref VALID_INPUT_FORMAT: String = serde_json::to_string(&serde_json::json!({
          "schema_id": "experimental",
          "data": [
            {
                "name": "{}-test-1",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-1",
                },
                "tags": [],
            },
            {
                "name": "{}-test-2",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-2",
                    "timeout_seconds": 60,
                },
                "tags": [],
            },
            {
                "name": "{}-test-3",
                "labels": ["{}-label"],
                "execution": {
                    "type": "fuchsia_component",
                    "component_url": "{}-test-url-3",
                    "test_args": ["--flag"],
                    "test_filters": ["Unit"],
                    "also_run_disabled_tests": true,
                    "parallel": 4,
                    "max_severity_logs": "INFO",
                },
                "tags": [{
                    "key": "hermetic",
                    "value": "true",
                }],
            }
        ]}))
        .expect("serialize json");
        static ref VALID_STDIN_INPUT: Vec<u8> =
            VALID_INPUT_FORMAT.replace("{}", "stdin").into_bytes();
        static ref VALID_FILE_INPUT: Vec<u8> =
            VALID_INPUT_FORMAT.replace("{}", "file").into_bytes();
        static ref INVALID_INPUT: Vec<u8> = vec![1u8; 64];
    }

    #[test]
    fn test_get_test_params() {
        let dir = tempfile::tempdir().expect("Create temp dir");
        std::fs::write(dir.path().join("test_defs.json"), &*VALID_FILE_INPUT).expect("write file");

        let cases = vec![
            (
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test-url".to_string()],
                    test_file: None,
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
                vec![run_test_suite_lib::TestParams {
                    test_url: "my-test-url".to_string(),
                    timeout_seconds: None,
                    test_filters: None,
                    also_run_disabled_tests: false,
                    parallel: None,
                    test_args: vec![],
                    max_severity_logs: None,
                    tags: vec![],
                }],
            ),
            (
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test-url".to_string()],
                    test_file: None,
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: Some(10),
                    min_severity_logs: None,
                    max_severity_logs: Some(diagnostics_data::Severity::Warn),
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
                vec![
                    run_test_suite_lib::TestParams {
                        test_url: "my-test-url".to_string(),
                        timeout_seconds: None,
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: Some(diagnostics_data::Severity::Warn),
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                    };
                    10
                ],
            ),
            (
                RunCommand {
                    timeout: Some(10),
                    test_args: vec!["my-test-url".to_string(), "--".to_string(), "arg".to_string()],
                    test_file: None,
                    test_filter: vec!["filter".to_string()],
                    run_disabled: true,
                    filter_ansi: false,
                    parallel: Some(20),
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
                vec![run_test_suite_lib::TestParams {
                    test_url: "my-test-url".to_string(),
                    timeout_seconds: Some(NonZeroU32::new(10).unwrap()),
                    test_filters: Some(vec!["filter".to_string()]),
                    also_run_disabled_tests: true,
                    max_severity_logs: None,
                    parallel: Some(20),
                    test_args: vec!["--".to_string(), "arg".to_string()],
                    tags: vec![],
                }],
            ),
            (
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: Some("-".to_string()),
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
                vec![
                    run_test_suite_lib::TestParams {
                        test_url: "stdin-test-url-1".to_string(),
                        timeout_seconds: None,
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "stdin-test-url-2".to_string(),
                        timeout_seconds: Some(NonZeroU32::new(60).unwrap()),
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "stdin-test-url-3".to_string(),
                        timeout_seconds: None,
                        test_filters: Some(vec!["Unit".to_string()]),
                        also_run_disabled_tests: true,
                        max_severity_logs: Some(diagnostics_data::Severity::Info),
                        parallel: Some(4),
                        test_args: vec!["--flag".to_string()],
                        tags: vec![TestTag {
                            key: "hermetic".to_string(),
                            value: "true".to_string(),
                        }],
                    },
                ],
            ),
            (
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: Some(
                        dir.path().join("test_defs.json").to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
                vec![
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-1".to_string(),
                        timeout_seconds: None,
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-2".to_string(),
                        timeout_seconds: Some(NonZeroU32::new(60).unwrap()),
                        test_filters: None,
                        also_run_disabled_tests: false,
                        max_severity_logs: None,
                        parallel: None,
                        test_args: vec![],
                        tags: vec![],
                    },
                    run_test_suite_lib::TestParams {
                        test_url: "file-test-url-3".to_string(),
                        timeout_seconds: None,
                        test_filters: Some(vec!["Unit".to_string()]),
                        also_run_disabled_tests: true,
                        max_severity_logs: Some(diagnostics_data::Severity::Info),
                        parallel: Some(4),
                        test_args: vec!["--flag".to_string()],
                        tags: vec![TestTag {
                            key: "hermetic".to_string(),
                            value: "true".to_string(),
                        }],
                    },
                ],
            ),
        ];

        for (run_command, expected_test_params) in cases.into_iter() {
            let result = test_params_from_args(
                run_command.clone(),
                || std::io::Cursor::new(&*VALID_STDIN_INPUT),
                true,
            );
            assert!(
                result.is_ok(),
                "Error getting test params from {:?}: {:?}",
                run_command,
                result.unwrap_err()
            );
            assert_eq!(result.unwrap(), expected_test_params);
        }
    }

    #[test]
    fn test_get_test_params_invalid_args() {
        let dir = tempfile::tempdir().expect("Create temp dir");
        std::fs::write(dir.path().join(VALID_INPUT_FILENAME), &*VALID_FILE_INPUT)
            .expect("write file");
        std::fs::write(dir.path().join(INVALID_INPUT_FILENAME), &*INVALID_INPUT)
            .expect("write file");
        let cases = vec![
            (
                "no tests specified",
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: None,
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
            ),
            (
                "tests specified in both args and file",
                RunCommand {
                    timeout: None,
                    test_args: vec!["my-test".to_string()],
                    test_file: Some(
                        dir.path().join(VALID_INPUT_FILENAME).to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
            ),
            (
                "read invalid input from file",
                RunCommand {
                    timeout: None,
                    test_args: vec![],
                    test_file: Some(
                        dir.path().join(INVALID_INPUT_FILENAME).to_str().unwrap().to_string(),
                    ),
                    test_filter: vec![],
                    run_disabled: false,
                    filter_ansi: false,
                    parallel: None,
                    count: None,
                    min_severity_logs: None,
                    max_severity_logs: None,
                    output_directory: None,
                    disable_output_directory: false,
                    continue_on_timeout: false,
                    stop_after_failures: None,
                },
            ),
        ];

        for (case_name, invalid_run_command) in cases.into_iter() {
            let result = test_params_from_args(
                invalid_run_command,
                || std::io::Cursor::new(&*VALID_STDIN_INPUT),
                true,
            );
            assert!(
                result.is_err(),
                "Getting test params for case '{}' unexpectedly succeeded",
                case_name
            );
        }
    }
}