//! DO NOT EDIT
//!
//! Generated with {{generated_with}}
//! Scenarios from <{{generated_from}}>
//!
#![cfg(all(feature = "python", feature = "pypi"))]

use std::env;
use std::process::Command;

use anyhow::Result;
use assert_cmd::assert::OutputAssertExt;
use assert_fs::fixture::{FileWriteStr, PathChild};
use predicates::prelude::predicate;

use common::{create_bin_with_executables, get_bin, puffin_snapshot, TestContext, INSTA_FILTERS};

mod common;

/// Provision python binaries and return a `pip compile` command with options shared across all scenarios.
fn command(context: &TestContext, python_versions: &[&str]) -> Command {
    let bin = create_bin_with_executables(&context.temp_dir, python_versions)
        .expect("Failed to create bin dir");
    let mut command = Command::new(get_bin());
    command
        .arg("pip")
        .arg("compile")
        .arg("requirements.in")
        .arg("--extra-index-url")
        .arg("https://test.pypi.org/simple")
        .arg("--cache-dir")
        .arg(context.cache_dir.path())
        .env("VIRTUAL_ENV", context.venv.as_os_str())
        .env("PUFFIN_NO_WRAP", "1")
        .env("PUFFIN_TEST_PYTHON_PATH", bin)
        .current_dir(&context.temp_dir);
    command
}

{{#scenarios}}

/// {{name}}
///
{{#description_lines}}
/// {{.}}
{{/description_lines}}
///
/// ```text
/// {{version}}
{{#tree}}
/// {{.}}
{{/tree}}
/// ```
#[test]
fn {{module_name}}() -> Result<()> {
    let context = TestContext::new("{{environment.python}}");
    let python_versions = &[{{#environment.additional_python}}"{{.}}", {{/environment.additional_python}}];

    // In addition to the standard filters, swap out package names for more realistic messages
    let mut filters = INSTA_FILTERS.to_vec();
    {{#packages}}
    filters.push((r"{{name}}", "{{cute_name}}"));
    {{/packages}}
    filters.push((r"-{{version}}", ""));

    let requirements_in = context.temp_dir.child("requirements.in");
    {{#root.requires}}
    requirements_in.write_str("{{requirement}}")?;
    {{/root.requires}}

    {{#expected.explanation_lines}}
    // {{.}}
    {{/expected.explanation_lines}}
    let output = puffin_snapshot!(filters, command(&context, python_versions)
        {{#resolver_options.prereleases}}
        .arg("--prerelease=allow")
        {{/resolver_options.prereleases}}
        {{#resolver_options.no_build}}
        .arg("--only-binary")
        .arg("{{.}}-{{version}}")
        {{/resolver_options.no_build}}
        {{#resolver_options.no_binary}}
        .arg("--no-binary")
        .arg("{{.}}-{{version}}")
        {{/resolver_options.no_binary}}
        {{#resolver_options.python}}
        .arg("--python-version={{.}}")
        {{/resolver_options.python}}, @r###"<snapshot>
    "###
    );

    output
        .assert()
    {{#expected.satisfiable}}
        .success()
        {{#expected.packages}}
            .stdout(predicate::str::contains("{{name}}=={{version}}"))
        {{/expected.packages}}
    {{/expected.satisfiable}}
    {{^expected.satisfiable}}
        .failure()
    {{/expected.satisfiable}}
    ;

    Ok(())
}
{{/scenarios}}