layeredconf 0.2.3

Layered configeration files, deserialized with serde
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use std::{env::current_dir, path::PathBuf};

use serde::{Deserialize, Serialize};

use layeredconf::{Builder, Error, Format, LayeredConf, Result, Source};

#[derive(LayeredConf, Deserialize, Serialize, Clone, Debug)]
struct Config {
    #[layered(load_config)]
    #[clap(long)]
    config: Option<PathBuf>,
    #[clap(long)]
    name: String,
}

#[test]
fn test() -> anyhow::Result<()> {
    let current_dir = current_dir()?;
    let arg_config = current_dir.join("tests/paths/arg/config.yaml");
    let arg_str = arg_config.to_str().unwrap();

    let args: Vec<String> = vec!["paths", "--config", arg_str]
        .iter()
        .map(|s| s.to_string())
        .collect();

    let config: Config = Builder::new()
        .new_layer(Source::File(
            PathBuf::from("./tests/paths/config.yaml"),
            Format::Auto,
        ))
        .new_layer(Source::ArgumentsFrom(args))
        .solidify()?;

    assert_eq!(config.name, "paths/arg/config.yaml");

    Ok(())
}

#[test]
fn test_loop() -> anyhow::Result<()> {
    let source = Source::File(
        PathBuf::from("./tests/paths/loop/config.yaml"),
        Format::Auto,
    );

    let result: Result<Config> = Builder::new().new_layer(source.clone()).solidify();

    assert!(matches!(result, Err(Error::LoopingLoadConfig { .. })));

    if let Err(Error::LoopingLoadConfig { path, parents }) = result {
        assert_eq!(path, current_dir()?.join("tests/paths/loop/config.yaml"));
        assert_eq!(
            parents,
            vec![
                Source::File(PathBuf::from("other_config.yaml"), Format::Auto),
                source,
            ],
        );
    }

    Ok(())
}