//! Tests for `include` config field.

use crate::prelude::*;
use cargo_test_support::compare::assert_e2e;
use cargo_test_support::str;

use super::config::GlobalContextBuilder;
use super::config::assert_error;
use super::config::write_config_at;
use super::config::write_config_toml;

#[cargo_test]
fn simple() {
    // Simple test.
    write_config_at(
        ".cargo/config.toml",
        "
        include = ['other.toml']
        key1 = 1
        key2 = 2
        ",
    );
    write_config_at(
        ".cargo/other.toml",
        "
        key2 = 3
        key3 = 4
        ",
    );
    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
    assert_eq!(gctx.get::<i32>("key3").unwrap(), 4);
}

#[cargo_test]
fn mix_of_hierarchy_and_include() {
    write_config_at(
        "foo/.cargo/config.toml",
        "
        include = ['other.toml']
        key1 = 1

        # also make sure unstable flags merge in the correct order
        [unstable]
        features = ['1']
        ",
    );
    write_config_at(
        "foo/.cargo/other.toml",
        "
        key1 = 2
        key2 = 2

        [unstable]
        features = ['2']
        ",
    );
    write_config_at(
        ".cargo/config.toml",
        "
        include = ['other.toml']
        key1 = 3
        key2 = 3
        key3 = 3

        [unstable]
        features = ['3']
        ",
    );
    write_config_at(
        ".cargo/other.toml",
        "
        key1 = 4
        key2 = 4
        key3 = 4
        key4 = 4

        [unstable]
        features = ['4']
        ",
    );
    let gctx = GlobalContextBuilder::new()
        .cwd("foo")
        .nightly_features_allowed(true)
        .build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
    assert_eq!(gctx.get::<i32>("key3").unwrap(), 3);
    assert_eq!(gctx.get::<i32>("key4").unwrap(), 4);
    assert_eq!(
        gctx.get::<Vec<String>>("unstable.features").unwrap(),
        vec![
            "4".to_string(),
            "3".to_string(),
            "2".to_string(),
            "1".to_string()
        ]
    );
}

#[cargo_test]
fn left_to_right_bottom_to_top() {
    // How it merges multiple nested includes.
    write_config_at(
        ".cargo/config.toml",
        "
        include = ['left-middle.toml', 'right-middle.toml']
        top = 1
        ",
    );
    write_config_at(
        ".cargo/right-middle.toml",
        "
        include = ['right-bottom.toml']
        top = 0
        right-middle = 0
        ",
    );
    write_config_at(
        ".cargo/right-bottom.toml",
        "
        top = -1
        right-middle = -1
        right-bottom = -1
        ",
    );
    write_config_at(
        ".cargo/left-middle.toml",
        "
        include = ['left-bottom.toml']
        top = -2
        right-middle = -2
        right-bottom = -2
        left-middle = -2
        ",
    );
    write_config_at(
        ".cargo/left-bottom.toml",
        "
        top = -3
        right-middle = -3
        right-bottom = -3
        left-middle = -3
        left-bottom = -3
        ",
    );
    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("top").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("right-middle").unwrap(), 0);
    assert_eq!(gctx.get::<i32>("right-bottom").unwrap(), -1);
    assert_eq!(gctx.get::<i32>("left-middle").unwrap(), -2);
    assert_eq!(gctx.get::<i32>("left-bottom").unwrap(), -3);
}

#[cargo_test]
fn nested_include_resolves_relative_to_including_file() {
    write_config_at(
        ".cargo/config.toml",
        "
        include = ['../config/cargo.toml']
        ",
    );
    write_config_at(
        "config/cargo.toml",
        "
        include = ['other.toml']
        middle = 10
        ",
    );
    write_config_at(
        "config/other.toml",
        "
        nested = 42
        ",
    );

    // This should not be included,
    // because `include` path is resolved relative to the including config
    // (where the `include` is defined)
    write_config_at(
        ".cargo/other.toml",
        "
        INVALID = SYNTAX
        ",
    );

    let gctx = GlobalContextBuilder::new().build();

    assert_eq!(gctx.get::<i32>("nested").unwrap(), 42);
    assert_eq!(gctx.get::<i32>("middle").unwrap(), 10);
}

#[cargo_test]
fn missing_file() {
    // Error when there's a missing file.
    write_config_toml("include=['missing.toml']");
    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  failed to load config include `missing.toml` from `[ROOT]/.cargo/config.toml`

Caused by:
  failed to read configuration file `[ROOT]/.cargo/missing.toml`

Caused by:
  [NOT_FOUND]
"#]],
    );
}

#[cargo_test]
fn wrong_file_extension() {
    // Error when it doesn't end with `.toml`.
    write_config_toml("include=['config.png']");
    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  expected a config include path ending with `.toml`, but found `config.png` from `[ROOT]/.cargo/config.toml`
"#]],
    );
}

#[cargo_test]
fn cycle() {
    // Detects a cycle.
    write_config_at(".cargo/config.toml", "include=['one.toml']");
    write_config_at(".cargo/one.toml", "include=['two.toml']");
    write_config_at(".cargo/two.toml", "include=['config.toml']");
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  failed to load config include `one.toml` from `[ROOT]/.cargo/config.toml`

Caused by:
  failed to load config include `two.toml` from `[ROOT]/.cargo/one.toml`

Caused by:
  failed to load config include `config.toml` from `[ROOT]/.cargo/two.toml`

Caused by:
  config `include` cycle detected with path `[ROOT]/.cargo/config.toml`
"#]],
    );
}

#[cargo_test]
fn cli_include() {
    // Using --config with include.
    // CLI takes priority over files.
    write_config_at(
        ".cargo/config.toml",
        "
        foo = 1
        bar = 2
        ",
    );
    write_config_at(".cargo/config-foo.toml", "foo = 2");
    let gctx = GlobalContextBuilder::new()
        .config_arg("include=['.cargo/config-foo.toml']")
        .build();
    assert_eq!(gctx.get::<i32>("foo").unwrap(), 2);
    assert_eq!(gctx.get::<i32>("bar").unwrap(), 2);
}

#[cargo_test]
fn bad_format() {
    // Not a valid format.
    write_config_toml("include = 1");
    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  expected a list of strings or a list of tables, but found integer at `include` in `[ROOT]/.cargo/config.toml
"#]],
    );
}

#[cargo_test]
fn cli_include_failed() {
    // Error message when CLI include fails to load.
    let gctx = GlobalContextBuilder::new()
        .config_arg("include=['foobar.toml']")
        .build_err();
    assert_error(
        gctx.unwrap_err(),
        str![[r#"
failed to load --config include

Caused by:
  failed to load config include `foobar.toml` from `--config cli option`

Caused by:
  failed to read configuration file `[ROOT]/foobar.toml`

Caused by:
  [NOT_FOUND]
"#]],
    );
}

#[cargo_test]
fn cli_merge_failed() {
    // Error message when CLI include merge fails.
    write_config_toml("foo = ['a']");
    write_config_at(
        ".cargo/other.toml",
        "
        foo = 'b'
        ",
    );
    let gctx = GlobalContextBuilder::new()
        .config_arg("include=['.cargo/other.toml']")
        .build_err();
    // Maybe this error message should mention it was from an include file?
    assert_error(
        gctx.unwrap_err(),
        str![[r#"
failed to merge key `foo` between [ROOT]/.cargo/config.toml and [ROOT]/.cargo/other.toml

Caused by:
  failed to merge config value from `[ROOT]/.cargo/other.toml` into `[ROOT]/.cargo/config.toml`: expected array, but found string
"#]],
    );
}

#[cargo_test]
fn cli_include_take_priority_over_env() {
    write_config_at(".cargo/include.toml", "k='include'");

    // k=env
    let gctx = GlobalContextBuilder::new().env("CARGO_K", "env").build();
    assert_eq!(gctx.get::<String>("k").unwrap(), "env");

    // k=env
    // --config 'include=".cargo/include.toml"'
    let gctx = GlobalContextBuilder::new()
        .env("CARGO_K", "env")
        .config_arg("include=['.cargo/include.toml']")
        .build();
    assert_eq!(gctx.get::<String>("k").unwrap(), "include");

    // k=env
    // --config '.cargo/foo.toml'
    write_config_at(".cargo/foo.toml", "include=['include.toml']");
    let gctx = GlobalContextBuilder::new()
        .env("CARGO_K", "env")
        .config_arg(".cargo/foo.toml")
        .build();
    assert_eq!(gctx.get::<String>("k").unwrap(), "include");
}

#[cargo_test]
fn inline_table_style() {
    write_config_at(
        ".cargo/config.toml",
        "
        include = ['simple.toml', { path = 'other.toml' }]
        key1 = 1
        key2 = 2
        ",
    );
    write_config_at(
        ".cargo/simple.toml",
        "
        key2 = 3
        key3 = 4
        ",
    );
    write_config_at(
        ".cargo/other.toml",
        "
        key3 = 5
        key4 = 6
        ",
    );

    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
    assert_eq!(gctx.get::<i32>("key3").unwrap(), 5);
    assert_eq!(gctx.get::<i32>("key4").unwrap(), 6);
}

#[cargo_test]
fn array_of_tables_style() {
    write_config_at(
        ".cargo/config.toml",
        "
        key1 = 1
        key2 = 2

        [[include]]
        path = 'other1.toml'

        [[include]]
        path = 'other2.toml'
        ",
    );
    write_config_at(
        ".cargo/other1.toml",
        "
        key2 = 3
        key3 = 4
        ",
    );
    write_config_at(
        ".cargo/other2.toml",
        "
        key3 = 5
        key4 = 6
        ",
    );

    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
    assert_eq!(gctx.get::<i32>("key3").unwrap(), 5);
    assert_eq!(gctx.get::<i32>("key4").unwrap(), 6);
}

#[cargo_test]
fn table_with_unknown_fields() {
    // Unknown fields should be ignored for forward compatibility
    write_config_at(
        ".cargo/config.toml",
        "
        key1 = 1

        [[include]]
        path = 'other.toml'
        unknown_foo = true
        unknown_bar = 123
        ",
    );
    write_config_at(
        ".cargo/other.toml",
        "
        key2 = 2
        ",
    );

    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
}

#[cargo_test]
fn table_missing_required_field() {
    // Missing required field should fail
    write_config_at(
        ".cargo/config.toml",
        "
        key1 = 1
        [[include]]
        random_field = true
        ",
    );

    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  missing field `path` at `include[0]` in `[ROOT]/.cargo/config.toml`
"#]],
    );
}

#[cargo_test]
fn optional_include_missing_and_existing() {
    write_config_at(
        ".cargo/config.toml",
        "
        key1 = 1

        [[include]]
        path = 'missing.toml'
        optional = true

        [[include]]
        path = 'other.toml'
        optional = true
        ",
    );
    write_config_at(
        ".cargo/other.toml",
        "
        key2 = 2
        ",
    );

    let gctx = GlobalContextBuilder::new().build();
    assert_eq!(gctx.get::<i32>("key1").unwrap(), 1);
    assert_eq!(gctx.get::<i32>("key2").unwrap(), 2);
}

#[cargo_test]
fn optional_false_missing_file() {
    write_config_at(
        ".cargo/config.toml",
        "
        key1 = 1

        [[include]]
        path = 'missing.toml'
        optional = false
        ",
    );

    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  failed to load config include `missing.toml` from `[ROOT]/.cargo/config.toml`

Caused by:
  failed to read configuration file `[ROOT]/.cargo/missing.toml`

Caused by:
  [NOT_FOUND]
"#]],
    );
}

#[cargo_test]
fn disallow_glob_syntax() {
    // Reserved for future extension
    write_config_toml("include = ['config-*.toml']");
    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  expected a config include path without glob patterns, but found `config-*.toml` from `[ROOT]/.cargo/config.toml`
"#]],
    );
}

#[cargo_test]
fn disallow_template_syntax() {
    // Reserved for future extension
    write_config_toml("include = ['{workspace-root}/config.toml']");
    // Config values are lazy loaded and fail at first retrieval.
    // This ensures simple commands like `cargo --version` working even when
    let gctx = GlobalContextBuilder::new().build();
    assert_error(
        gctx.get::<bool>("foo").unwrap_err(),
        str![[r#"
could not load Cargo configuration

Caused by:
  expected a config include path without template braces, but found `{workspace-root}/config.toml` from `[ROOT]/.cargo/config.toml`
"#]],
    );
}

#[cargo_test]
fn env_relative_path_included_from_same_level() {
    // See https://github.com/rust-lang/cargo/issues/16954
    write_config_at(
        "foo/.cargo/config.toml",
        "
        include = ['../../inc/inc.toml']

        [env]
        INNER = { value = 'inner-val', relative = true }
        ",
    );
    write_config_at(
        "inc/inc.toml",
        "
        [env]
        OUTER = { value = 'outer-val', relative = true }
        ",
    );
    let gctx = GlobalContextBuilder::new().cwd("foo").build();
    let env = gctx.env_config().unwrap();

    assert_e2e().eq(
        env.get("INNER").unwrap().to_str().unwrap(),
        str!["[ROOT]/foo/inner-val"],
    );
    assert_e2e().eq(
        env.get("OUTER").unwrap().to_str().unwrap(),
        str!["[ROOT]/outer-val"],
    );
}

#[cargo_test]
fn env_relative_path_included_from_upper_level() {
    // See https://github.com/rust-lang/cargo/issues/16954
    write_config_at(
        "outer/foo/.cargo/config.toml",
        "
        include = ['../../inc.toml']
        ",
    );
    write_config_at(
        "outer/inc.toml",
        "
        [env]
        MY_ENV = { value = 'val', relative = true }
        ",
    );
    let gctx = GlobalContextBuilder::new().cwd("outer/foo").build();
    let env = gctx.env_config().unwrap();

    assert_e2e().eq(
        env.get("MY_ENV").unwrap().to_str().unwrap(),
        str!["[ROOT]/val"],
    );
}

#[cargo_test]
fn env_relative_path_included_override() {
    // See https://github.com/rust-lang/cargo/issues/16954
    write_config_at(
        "foo/.cargo/config.toml",
        "
        include = ['../../inc/inc.toml']

        [env]
        MY_ENV = { value = 'inner', relative = true }
        ",
    );
    write_config_at(
        "inc/inc.toml",
        "
        [env]
        MY_ENV = { value = 'outer', relative = true }
        ",
    );
    let gctx = GlobalContextBuilder::new().cwd("foo").build();
    let env = gctx.env_config().unwrap();
    let my_env = env.get("MY_ENV").unwrap();

    assert_e2e().eq(my_env.to_str().unwrap(), str!["[ROOT]/foo/inner"]);
}

#[cargo_test]
fn env_relative_path_nested_included_override() {
    // See https://github.com/rust-lang/cargo/issues/16954
    write_config_at(
        "foo/.cargo/config.toml",
        "
        include = ['../../mid/mid.toml']

        [env]
        MY_ENV = { value = 'inner', relative = true }
        ",
    );
    write_config_at(
        "mid/mid.toml",
        "
        include = ['../deep/deep.toml']

        [env]
        MY_ENV = { value = 'mid', relative = true }
        ",
    );
    write_config_at(
        "deep/deep.toml",
        "
        [env]
        MY_ENV = { value = 'deep', relative = true }
        ",
    );
    let gctx = GlobalContextBuilder::new().cwd("foo").build();
    let env = gctx.env_config().unwrap();
    let my_env = env.get("MY_ENV").unwrap();

    assert_e2e().eq(my_env.to_str().unwrap(), str!["[ROOT]/foo/inner"]);
}
