konfy 0.1.0

Configure gui, tui, repl and cli applications
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

from dataclasses import asdict

import pytest

from konfy import Configuration, Identifier, Konfy, Setting


@pytest.fixture()
def app():
    return "testapp"


@pytest.fixture()
def default_level():
    return "debug"


@pytest.fixture()
def env_level():
    return "error"


@pytest.fixture()
def default_timeout():
    return 45


@pytest.fixture()
def env_timeout():
    return 60


@pytest.fixture()
def defaults(default_level, default_timeout):
    return {"logging": {"level": default_level}, "timeout": default_timeout}


@pytest.fixture()
def env(env_level, env_timeout):
    return {"logging": {"level": env_level}, "timeout": env_timeout}


@pytest.fixture()
def konfy(app, defaults):
    return Konfy(
        application=app,
        cli=None,
        environment=None,
        app_config=None,
        user_config=None,
        system_config=None,
        defaults=defaults,
    )


@pytest.fixture()
def konfy_with_env_and_default(app, env, defaults):
    return Konfy(
        application=app,
        cli=None,
        environment=env,
        app_config=None,
        user_config=None,
        system_config=None,
        defaults=defaults,
    )


def test_konfy_configuration_with_defaults_only(konfy, defaults):
    expected = defaults
    actual = dict(konfy.config)
    assert actual == expected


def test_access_configuration_using_index_operator(konfy, default_level):
    cfg = konfy.config
    expected = default_level
    actual = cfg["logging"]["level"]
    assert actual == expected


def test_access_configuration_using_attribute_access(konfy, default_timeout):
    cfg = konfy.config
    expected = default_timeout
    actual = cfg.timeout
    assert actual == expected


def test_access_configuration_using_nested_attribute_access(konfy, default_level):
    cfg = konfy.config
    expected = default_level
    actual = cfg.logging.level
    assert actual == expected


def test_env_has_higher_priority_than_defaults(
    konfy_with_env_and_default, env_level, env_timeout,
):
    konfy = konfy_with_env_and_default
    cfg = konfy.config

    expected = env_level
    actual = cfg.logging.level

    assert actual == expected

    expected = env_timeout
    actual = cfg.timeout

    assert actual == expected


@pytest.fixture()
def configuration():
    config = Configuration()
    logging_ns = config.add_namespace("logging")
    logging_ns.add_setting(
        "level",
        str,
        default="info",
        description="The log level to use",
        help="Log level of the application, possible values[debug, info, warn, error]",
    )
    timeout_ns = config.add_namespace("timeout")
    hard_ns = timeout_ns.add_namespace("hard")
    hard_ns.add_setting("timeout", int, default=45, description="desc", help="some help")
    soft_ns = timeout_ns.add_namespace("soft")
    soft_ns.add_setting("timeout", int, default=45, description="desc", help="some help")
    return config

def test_create_nested_namespace(configuration):
    logging_ns = configuration.add_namespace("logging")
    logging_ns.add_setting(
        "level",
        str,
        default="info",
        description="The log level to use",
        help="Log level of the application, possible values[debug, info, warn, error]",
    )

    timeout_ns = configuration.add_namespace("timeout")

    hard_ns = timeout_ns.add_namespace("hard")
    hard_ns.add_setting("timeout", int, default=45, description="desc", help="some help")
    soft_ns = timeout_ns.add_namespace("soft")
    soft_ns.add_setting("timeout", int, default=45, description="desc", help="some help")

    expected = asdict(Setting(
        name=Identifier("logging:level"),
        type=str,
        default="info",
        description="The log level to use",
        help="Log level of the application, possible values[debug, info, warn, error]",
    ))
    actual = asdict(configuration["logging"]["level"])

    assert actual == expected

@pytest.mark.skip()
def test_idea_smoke(configuration):
    settings = configuration
    #konfy = Konfy.from_settings(name="foo", settings, argparser, env)


@pytest.mark.skip(reason="just a outline for the future")
def test_create_defaults():
    from konfy import Defaults, Konfy, Setting

    defaults = {"logging:level": "debug"}
    defaults = Defaults(
        [
            Setting(
                name="logging:level",
            ),
            Setting(
                ns="logging",
                name="facitlity",
                type=int,
                value=2,
                description="",
                help="",
            ),
        ],
    )

    settings = Konfy(
        name="foo",  # name of the application the konfy object is for
        cli={},  # Dict (parsed) / Could be argsparser (argparse object)
        environment=None,  # default os.environ
        app_config=None,  # default <cwd>app_name.toml
        user_config=None,  # default os sepecific e.g. linux = ~/config/app_name/config.toml
        system_config=None,  # default os specific e.g. linux /etc/<cwd>app_name.toml
        defaults=None,  # A iterable of default settings
    )