figen 0.2.0

Strongly typed configuration bindings and registries generated from a declarative schema
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use figen::Configuration;

mod utils;

#[derive(Configuration, Debug, Default)]
struct MyConfig {
    #[property(optional)]
    i32_field: i32,
    #[property(optional)]
    bool_field: bool,
    #[property(optional)]
    string_field: utils::StringType,
    #[property(optional)]
    optional_field: Option<i32>,
    #[property]
    nested_array: [i32; 2],
    #[property(indices = ["i1", "i2"])]
    custom_indexed: [i32; 2],
}

#[test]
fn should_attempt_to_load_keys() {
    let loader = utils::MockLoader::new();

    let _: figen::Result<MyConfig> = figen::load_config(&loader);
    let attempted_keys = loader.get_attempted_keys();

    let expected_keys = vec![
        "i32_field".to_string(),
        "bool_field".to_string(),
        "string_field".to_string(),
        "optional_field".to_string(),
        "nested_array[0]".to_string(),
        "nested_array[1]".to_string(),
        "custom_indexed[i1]".to_string(),
        "custom_indexed[i2]".to_string(),
    ];
    assert_eq!(
        attempted_keys, expected_keys,
        "The keys attempted to load do not match the expected keys."
    );
}

#[test]
fn should_load_config_values() {
    let loader = utils::MockLoader::new()
        .with_data("i32_field", "1234")
        .with_data("bool_field", "false") // Different from default
        .with_data("string_field", "test_string")
        .with_data("optional_field", "12") // Different from default
        .with_data("nested_array[0]", "1")
        .with_data("nested_array[1]", "2")
        .with_data("custom_indexed[i1]", "30")
        .with_data("custom_indexed[i2]", "40");

    let config: MyConfig = figen::load_config(&loader).expect("Failed to load configuration");

    assert_eq!(config.i32_field, 1234);
    assert_eq!(config.bool_field, false);
    assert_eq!(config.string_field, "test_string");
    assert_eq!(config.optional_field, Some(12));
    assert_eq!(config.nested_array[0], 1);
    assert_eq!(config.nested_array[1], 2);
    assert_eq!(config.custom_indexed[0], 30);
    assert_eq!(config.custom_indexed[1], 40);
}

#[derive(Configuration, Debug, Default)]
struct TestConfig {
    #[property] // no default value
    required_field: i32,
    #[property()]
    optional_field: i32,
    #[property] // Option<> types are fine with no default
    optional_field2: Option<i32>,
}

#[test]
fn should_err_when_required_property_missing() {
    let loader = utils::MockLoader::new()
        .with_data("optional_field", "200")
        .with_data("optional_field2", "300");

    let result: figen::Result<TestConfig> = figen::load_config(&loader);

    assert!(
        result.is_err(),
        "Expected an error when required property is missing and no default provided"
    );
    let err = result.unwrap_err();
    assert_eq!(
        err,
        figen::error::Error::Required,
        "Expected Required error, got {:?}",
        err
    );
}