def test_envless_mode(tmpdir):
data = {
"foo": "bar",
"hello": "world",
"default": 1,
"databases": {
"default": {
"port": 8080
}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data)
settings = LazySettings(
settings_file="settings.toml") # already the default
assert settings.FOO == "bar"
assert settings.HELLO == "world"
assert settings.DEFAULT == 1
assert settings.DATABASES.default.port == 8080
def test_local_files(tmpdir):
settings_file_yaml = """
default:
name: Bruno
colors:
- green
- blue
data:
link: brunorocha.org
other:
foo: bar
music:
current:
volume: 10
title: The Beatles - Strawberry Fields
"""
tmpdir.join("settings.yaml").write(settings_file_yaml)
local_file_yaml = """
default:
name: Bruno Rocha
colors:
- red
- dynaconf_merge
data:
city: Guarulhos
dynaconf_merge: true
other:
baz: zaz
music__current__volume: 100
music__current__title: Led Zeppelin - Immigrant Song
"""
tmpdir.join("settings.local.yaml").write(local_file_yaml)
conf = LazySettings()
assert conf.NAME == "Bruno Rocha"
assert set(conf.COLORS) == set(["red", "green", "blue"])
assert conf.DATA.link == "brunorocha.org"
assert conf.DATA.city == "Guarulhos"
assert conf.OTHER == {"baz": "zaz"}
assert conf.MUSIC.current.volume == 100
assert conf.MUSIC.current.title == "Led Zeppelin - Immigrant Song"
def test_ignoring_duplicate_validators(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(
ENV_FOR_DYNACONF="EXAMPLE",
SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True,
)
validator1 = Validator("VERSION", "AGE", "NAME", must_exist=True)
settings.validators.register(
validator1, Validator("VERSION", "AGE", "NAME", must_exist=True))
assert len(settings.validators) == 1
settings.validators.register(validator1)
assert len(settings.validators) == 1
def test_clone_with_module_type():
# create a settings object
settings = LazySettings(FOO="bar", A_MODULE=os)
# adding a module type makes object unpickaable
# then .clone raised an error, this was fixed by copying the dict.
assert settings.FOO == "bar"
# clone it
cloned = settings.dynaconf.clone()
assert cloned.FOO == "bar"
# modify the cloned settings
cloned.FOO = "baz"
assert cloned.FOO == "baz"
# assert original settings is not modified
assert settings.FOO == "bar"
assert settings.A_MODULE == cloned.A_MODULE
def test_validators_on_init(tmpdir):
TOML = """
[default]
hostname = 'devserver.com'
username = '******'
"""
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(
environments=True,
settings_file=str(tmpfile),
validators=(
Validator("hostname", eq="devserver.com"),
Validator("username", ne="admin"),
),
)
with pytest.raises(ValidationError):
settings.HOSTNAME
def test_validator_descriptions_flat(tmpdir):
validators = ValidatorList(
LazySettings(),
validators=[
Validator("foo", description="foo"),
Validator("bar", description="bar"),
Validator("baz", "zaz", description="baz zaz"),
Validator("foo", description="another message"),
Validator("a", description="a") & Validator("b"),
],
)
assert validators.descriptions(flat=True) == {
"bar": "bar",
"baz": "baz zaz",
"zaz": "baz zaz",
"foo": "foo",
"a": "a",
"b": "a",
}
def test_validator_can_provide_default(tmpdir):
tmpfile = tmpdir.join("settings.toml")
TOML = """
name = 'Bruno'
colors = ['red', 'green', 'blue']
"""
tmpfile.write(TOML)
settings = LazySettings(
settings_file=str(tmpfile),
validators=[
Validator("name", required=True),
Validator("FOO", default="BAR"),
Validator("COMPUTED", default=lambda st, va: "I am computed"),
],
)
assert settings.name == "Bruno"
assert settings.colors == ["red", "green", "blue"]
assert settings.FOO == "BAR"
assert settings.COMPUTED == "I am computed"
def test_validator_custom_message(tmpdir):
"""Assert custom message is being processed by validator."""
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True)
custom_msg = "You cannot set {name} to {value} in env {env}"
settings.validators.register(
Validator("MYSQL_HOST", eq="development.com", env="DEVELOPMENT"),
Validator("MYSQL_HOST", ne="development.com", env="PRODUCTION"),
Validator("VERSION", ne=1, messages={"operations": custom_msg}),
)
with pytest.raises(ValidationError) as error:
settings.validators.validate()
assert custom_msg.format(name="VERSION", value="1",
env="DEVELOPMENT") in str(error)
def load_config_at_path(path):
"""Load config at exact path
Args:
path (path-like): path to config file
Returns:
dict: config dict
"""
if path.exists() and path.is_file():
options = DYNACONF_OPTIONS.copy()
options.update({
'ROOT_PATH_FOR_DYNACONF': safepath(path.parent),
'SETTINGS_FILE_FOR_DYNACONF': safepath(path.name),
})
return LazySettings(**options)
else:
raise ConfigurationError(
'Couldn\'t find ballet.yml config file at {path!s}'
.format(path=path))
def test_set_new_merge_issue_241_1(tmpdir):
data = {
"default": {
"name": "Bruno",
"colors": ["red", "green"],
"data": {
"links": {
"twitter": "rochacbruno",
"site": "brunorocha.org"
}
},
}
}
toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False)
settings = LazySettings(environments=True, settings_file="settings.toml")
assert settings.NAME == "Bruno"
assert settings.COLORS == ["red", "green"]
assert settings.DATA.links == {
"twitter": "rochacbruno",
"site": "brunorocha.org",
}
def test_envless_mode_with_prefix(tmpdir):
data = {
"prefix_foo": "bar",
"hello": "world",
"prefix_default": 1,
"prefix_databases": {
"default": {
"port": 8080
}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data)
settings = LazySettings(
settings_file="settings.toml",
filter_strategy=PrefixFilter("prefix")) # already the default
assert settings.FOO == "bar"
with pytest.raises(AttributeError):
settings.HELLO
assert settings.DEFAULT == 1
assert settings.DATABASES.default.port == 8080
def test_no_reload_on_single_env(tmpdir, mocker):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
same_env_validator = Validator("VERSION",
is_type_of=int,
env="development")
other_env_validator = Validator("NAME", must_exist=True, env="production")
settings = LazySettings(ENV_FOR_DYNACONF="DEVELOPMENt",
SETTINGS_FILE_FOR_DYNACONF=str(tmpfile))
using_env = mocker.patch.object(settings, "from_env")
settings.validators.register(same_env_validator)
settings.validators.validate()
using_env.assert_not_called()
settings.validators.register(other_env_validator)
settings.validators.validate()
using_env.assert_any_call("production")
assert using_env.call_count == 1
def test_lowercase_read_mode(tmpdir):
"""
Starting on 3.0.0 lowercase keys are enabled by default
"""
data = {
"foo": "bar",
"hello": "world",
"default": 1,
"databases": {
"default": {
"port": 8080
}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data)
# settings_files mispelled.. should be `settings_file`
settings = LazySettings(settings_files="settings.toml")
assert settings.FOO == "bar"
assert settings.foo == "bar"
assert settings.HELLO == "world"
assert settings.hello == "world"
assert settings.DEFAULT == 1
assert settings.default == 1
assert settings.DATABASES.default.port == 8080
assert settings.databases.default.port == 8080
assert "foo" in settings
assert "FOO" in settings
# test __dir__
results = dir(settings)
assert "foo" in results
assert "FOO" in results
results = dir(settings.databases)
assert "default" in results
assert "DEFAULT" in results
def test_config_aliases(tmpdir):
data = {
"hello": {
"name": "Bruno",
"passwd": 1234
},
"awesome": {
"passwd": 5678
},
}
toml_loader.write(str(tmpdir.join("blarg.toml")), data, merge=False)
settings = LazySettings(
envvar_prefix="BRUCE",
core_loaders=["TOML"],
loaders=["dynaconf.loaders.env_loader"],
default_env="hello",
env_switcher="BRUCE_ENV",
prelaod=[],
settings_file=["blarg.toml"],
includes=[],
ENV="awesome",
environments=True,
)
assert settings.NAME == "Bruno"
assert settings.PASSWD == 5678
assert settings.ENVVAR_PREFIX_FOR_DYNACONF == "BRUCE"
assert settings.CORE_LOADERS_FOR_DYNACONF == ["TOML"]
assert settings.LOADERS_FOR_DYNACONF == ["dynaconf.loaders.env_loader"]
assert len(settings._loaders) == 1
assert settings.DEFAULT_ENV_FOR_DYNACONF == "hello"
assert settings.ENV_SWITCHER_FOR_DYNACONF == "BRUCE_ENV"
assert settings.PRELOAD_FOR_DYNACONF == []
assert settings.SETTINGS_FILE_FOR_DYNACONF == ["blarg.toml"]
assert settings.INCLUDES_FOR_DYNACONF == []
assert settings.ENV_FOR_DYNACONF == "awesome"
assert settings.current_env == "awesome"
def test_cast_before_validate(tmpdir):
tmpfile = tmpdir.join("settings.toml")
TOML = """
name = 'Bruno'
colors = ['red', 'green', 'blue']
"""
tmpfile.write(TOML)
settings = LazySettings(
settings_file=str(tmpfile),
silent=True,
lowercase_read=True,
validators=[
Validator("name", len_eq=5),
Validator("name", len_min=1),
Validator("name", len_max=5),
Validator("colors", len_eq=3),
Validator("colors", len_eq=3),
Validator("colors", len_eq=24, cast=str),
],
)
assert settings.name == "Bruno"
assert settings.colors == ["red", "green", "blue"]
def test_settings_dict_like_iteration(tmpdir):
"""Settings can be iterated just like a dict"""
data = {
"foo": "bar",
"hello": "world",
"default": 1,
"databases": {
"default": {
"port": 8080
}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data)
# settings_files mispelled.. should be `settings_file`
settings = LazySettings(settings_files="settings.toml")
for key in settings:
assert key in settings._store
for key, value in settings.items():
assert settings._store[key] == value
def test_config_aliases(tmpdir):
data = {
"hello": {
"name": "Bruno",
"passwd": 1234
},
"awesome": {
"passwd": 5678
},
}
toml_loader.write(str(tmpdir.join("blarg.toml")), data, merge=False)
settings = LazySettings(
ENVVAR_PREFIX="BRUCE",
CORE_LOADERS=["TOML"],
LOADERS=["dynaconf.loaders.env_loader"],
DEFAULT_ENV="hello",
ENV_SWITCHER="BRUCE_ENV",
PRELOAD=[],
SETTINGS_FILE=["blarg.toml"],
INCLUDES=[],
ENV="awesome",
)
assert settings.NAME == "Bruno"
assert settings.PASSWD == 5678
assert settings.ENVVAR_PREFIX_FOR_DYNACONF == "BRUCE"
assert settings.CORE_LOADERS_FOR_DYNACONF == ["TOML"]
assert settings.LOADERS_FOR_DYNACONF == ["dynaconf.loaders.env_loader"]
assert len(settings._loaders) == 1
assert settings.DEFAULT_ENV_FOR_DYNACONF == "hello"
assert settings.ENV_SWITCHER_FOR_DYNACONF == "BRUCE_ENV"
assert settings.PRELOAD_FOR_DYNACONF == []
assert settings.SETTINGS_FILE_FOR_DYNACONF == ["blarg.toml"]
assert settings.INCLUDES_FOR_DYNACONF == []
assert settings.ENV_FOR_DYNACONF == "awesome"
assert settings.current_env == "awesome"
def test_preload(tmpdir):
data = {
"default": {
"data": {
"links": {"twitter": "rochacbruno", "site": "brunorocha.org"}
}
}
}
toml_loader.write(str(tmpdir.join("preload.toml")), data, merge=False)
data = {
"dynaconf_merge": True,
"default": {"data": {"links": {"github": "rochacbruno.github.io"}}},
}
toml_loader.write(
str(tmpdir.join("main_settings.toml")), data, merge=False
)
data = {
"dynaconf_merge": True,
"default": {
"data": {"links": {"mastodon": "mastodon.social/@rochacbruno"}}
},
}
toml_loader.write(str(tmpdir.join("included.toml")), data, merge=False)
settings = LazySettings(
PRELOAD_FOR_DYNACONF=["preload.toml"],
SETTINGS_FILE_FOR_DYNACONF="main_settings.toml",
INCLUDES_FOR_DYNACONF=["included.toml"],
)
assert settings.DATA.links == {
"twitter": "rochacbruno",
"site": "brunorocha.org",
"github": "rochacbruno.github.io",
"mastodon": "mastodon.social/@rochacbruno",
}
def test_set_new_merge_issue_241_2(tmpdir):
data = {
"default": {
"name": "Bruno",
"colors": ["red", "green"],
"data": {
"links": {
"twitter": "rochacbruno",
"site": "brunorocha.org"
}
},
}
}
toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False)
data = {
"dynaconf_merge": True,
"default": {
"colors": ["blue"],
"data": {
"links": {
"github": "rochacbruno.github.io"
}
},
},
}
toml_loader.write(str(tmpdir.join("settings.local.toml")),
data,
merge=False)
settings = LazySettings()
assert settings.NAME == "Bruno"
assert settings.COLORS == ["red", "green", "blue"]
assert settings.DATA.links == {
"twitter": "rochacbruno",
"site": "brunorocha.org",
"github": "rochacbruno.github.io",
}
def test_set_new_merge_issue_241_4(tmpdir):
data = {
"name": "Bruno",
"colors": ["red", "green"],
"data": {
"links": {"twitter": "rochacbruno", "site": "brunorocha.org"}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False)
data = {"data__links__telegram": "t.me/rochacbruno"}
toml_loader.write(
str(tmpdir.join("settings.local.toml")), data, merge=False
)
settings = LazySettings(settings_file="settings.toml")
assert settings.NAME == "Bruno"
assert settings.COLORS == ["red", "green"]
assert settings.DATA.links == {
"twitter": "rochacbruno",
"site": "brunorocha.org",
"telegram": "t.me/rochacbruno",
}
def test_set_new_merge_issue_241_3(tmpdir):
data = {
"name": "Bruno",
"colors": ["red", "green"],
"data": {
"links": {"twitter": "rochacbruno", "site": "brunorocha.org"}
},
}
toml_loader.write(str(tmpdir.join("settings.toml")), data, merge=False)
data = {
"name": "Tommy Shelby",
"colors": {"dynaconf_merge": ["yellow", "pink"]},
"data": {"links": {"site": "pb.com"}},
}
toml_loader.write(
str(tmpdir.join("settings.local.toml")), data, merge=False
)
settings = LazySettings(settings_file="settings.toml")
assert settings.NAME == "Tommy Shelby"
assert settings.COLORS == ["red", "green", "yellow", "pink"]
assert settings.DATA.links == {"site": "pb.com"}
def test_should_not_duplicate_with_global_merge(tmpdir):
"""Assert merge unique in a first level. Issue #653"""
settings_file_yaml = """
default:
SOME_KEY: "value"
SOME_LIST:
- "item_1"
- "item_2"
- "item_3"
other:
SOME_KEY: "new_value"
SOME_LIST:
- "item_4"
- "item_5"
even_other:
SOME_KEY: "new_value_2"
SOME_LIST:
- "item_6"
- "item_7"
"""
tmpdir.join("settings.yaml").write(settings_file_yaml)
settings = LazySettings(environments=True,
settings_files=["settings.yaml"],
merge_enabled=True)
# settings.reload()
assert settings.SOME_KEY == "value"
assert settings.SOME_LIST == ["item_1", "item_2", "item_3"]
other_settings = settings.from_env("other")
assert other_settings.SOME_KEY == "new_value"
assert other_settings.SOME_LIST == [
"item_1",
"item_2",
"item_3",
"item_4",
"item_5",
]
from dynaconf import LazySettings, Validator
from uptimer import ROOT_PATH
settings = LazySettings(
DEBUG_LEVEL_FOR_DYNACONF="DEBUG",
CORE_LOADERS_FOR_DYNACONF=["TOML", "ENV"],
ENV_SWITCHER_FOR_DYNACONF="UPTIMER_ENV",
ENVVAR_PREFIX_FOR_DYNACONF=False,
LOADERS_FOR_DYNACONF=["dynaconf.loaders.env_loader"],
ROOT_PATH_FOR_DYNACONF=ROOT_PATH,
SETTINGS_FILE_FOR_DYNACONF="settings.toml,.secrets.toml",
)
settings.validators.register(
# Ensure writer plugin exists
Validator("WRITER_PLUGIN", must_exist=True),
# Ensure reader plugin exists, but only when queue plugin does not
Validator("READER_PLUGIN",
must_exist=True,
when=Validator("QUEUE_PLUGIN", eq="")),
)
settings.validators.validate()
from dynaconf import LazySettings
settings = LazySettings(envless_mode=True, lowercase_read=True)
assert settings.server == "foo.com"
assert settings.SERVER == "foo.com"
assert settings["SERVER"] == "foo.com"
assert settings["server"] == "foo.com"
assert settings("SERVER") == "foo.com"
assert settings("server") == "foo.com"
assert settings.get("SERVER") == "foo.com"
assert settings.get("server") == "foo.com"
import sys
import json
from typing import Dict
from dynaconf import LazySettings
from opa.core.logger import log
config = LazySettings()
from opa.core.plugin import (
HookDefinition,
Hook,
Driver,
Setup,
get_plugin_manager,
get_util,
get_component,
get_instance,
get_router,
call_hook,
call_hook_async,
)
def init_configuration():
config.configure(
ENV_SWITCHER_FOR_DYNACONF='ENV',
ENVVAR_PREFIX_FOR_DYNACONF='OPA',
ROOT_PATH_FOR_DYNACONF='/data/settings',
ENVIRONMENTS_FOR_DYNACONF=True,
def test_post_load_hooks(clean_env, tmpdir):
"""Test post load hooks works
This test uses 3 settings files
PRELOAD = "plugin_folder/plugin.py"
SETTINGS_FILE = "settings.py"
HOOKFILES = ["plugin_folder/dynaconf_hooks.py", "dynaconf_hooks.py"]
The hook file has a function called "post" which is called after
loading the settings, that function accepts the argument `settings`
which is a copy of the settings object, and returns a dictionary
of settings to be merged.
"""
# Arrange
plugin_folder = tmpdir.mkdir("plugin_folder")
plugin_folder.join("__init__.py").write('print("initing plugin...")')
plugin_path = plugin_folder.join("plugin.py")
plugin_hook = plugin_folder.join("dynaconf_hooks.py")
settings_path = tmpdir.join("settings.py")
settings_hook = tmpdir.join("dynaconf_hooks.py")
to_write = {
str(plugin_path): ["PLUGIN_NAME = 'DummyPlugin'"],
str(settings_path): [
"INSTALLED_APPS = ['admin']",
"COLORS = ['red', 'green']",
"DATABASES = {'default': {'NAME': 'db'}}",
"BANDS = ['Rush', 'Yes']",
],
str(plugin_hook): [
"post = lambda settings: "
"{"
"'PLUGIN_NAME': settings.PLUGIN_NAME.lower(),"
"'COLORS': '@merge blue',"
"'DATABASES__default': '@merge PORT=5151',"
"'DATABASES__default__VERSION': 42,"
"'DATABASES__default__FORCED_INT': '@int 12',",
"'BANDS': ['Anathema', 'dynaconf_merge']"
"}",
],
str(settings_hook): [
"post = lambda settings: "
"{"
"'INSTALLED_APPS': [settings.PLUGIN_NAME],"
"'dynaconf_merge': True,"
"}"
],
}
for path, lines in to_write.items():
with open(str(path),
"w",
encoding=default_settings.ENCODING_FOR_DYNACONF) as f:
for line in lines:
f.write(line)
f.write("\n")
# Act
settings = LazySettings(preload=["plugin_folder.plugin"],
settings_file="settings.py")
# Assert
assert settings.PLUGIN_NAME == "dummyplugin"
assert settings.INSTALLED_APPS == ["admin", "dummyplugin"]
assert settings.COLORS == ["red", "green", "blue"]
assert settings.DATABASES.default.NAME == "db"
assert settings.DATABASES.default.PORT == 5151
assert settings.DATABASES.default.VERSION == 42
assert settings.DATABASES.default.FORCED_INT == 12
assert settings.BANDS == ["Rush", "Yes", "Anathema"]
assert settings._loaded_hooks[str(plugin_hook)] == {
"post": {
"PLUGIN_NAME": "dummyplugin",
"COLORS": "@merge blue",
"DATABASES__default": "@merge PORT=5151",
"DATABASES__default__VERSION": 42,
"DATABASES__default__FORCED_INT": "@int 12",
"BANDS": ["Anathema", "dynaconf_merge"],
}
}
assert settings._loaded_hooks[str(settings_hook)] == {
"post": {
"INSTALLED_APPS": ["dummyplugin"],
}
}
# -*- coding: utf-8 -*-
import multiprocessing
import os
from dynaconf import LazySettings
from common.utils import _ConfigParser
from common import constants
basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
settings = LazySettings(ROOT_PATH_FOR_DYNACONF=constants.BASE_DIR)
class BaseConfig:
"""
生产配置
"""
DEBUG = False
_LOCALES = ['en_US', 'zh_Hans_CN']
BABEL_DEFAULT_LOCALE = _LOCALES[0]
SECRET_KEY = os.getenv('SECRET_KEY', 'a secret string')
# 数据库配置
DATABASE_HOST = settings.get('HOST', '127.0.0.1')
DATABASE_PORT = settings.get('PORT', 3306)
DATABASE_USER = settings.get('USER', 'root')
DATABASE_PASSWORD = settings.get('PASSWORD', '123qwe,.')
DATABASE_NAME = settings.get('NAME', 'yzy_kvm_db')
# DATABASE_HOST = '127.0.0.1'
# DATABASE_PORT = 3306
# DATABASE_USER = '******'
# DATABASE_PASSWORD = '******'
def test_validators(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(
ENV_FOR_DYNACONF="EXAMPLE",
SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True,
)
settings.validators.register(
Validator("VERSION", "AGE", "NAME", must_exist=True),
Validator("AGE", lte=30, gte=10),
Validator("PROJECT", eq="hello_world"),
Validator("PRESIDENT", env="DEVELOPMENT", ne="Trump"),
Validator("SALARY", lt=1000000, gt=1000),
Validator("DEV_SERVERS", must_exist=True, is_type_of=(list, tuple)),
Validator("MYSQL_HOST", env="DEVELOPMENT", is_in=settings.DEV_SERVERS),
Validator("MYSQL_HOST",
env="PRODUCTION",
is_not_in=settings.DEV_SERVERS),
Validator("NAME", condition=lambda x: x in ("BRUNO", "MIKE")),
Validator(
"IMAGE_1",
"IMAGE_2",
env="development",
must_exist=True,
when=Validator("BASE_IMAGE",
must_exist=True,
env=settings.ENV_FOR_DYNACONF),
),
Validator(
"IMAGE_4",
"IMAGE_5",
env=("development", "production"),
must_exist=True,
when=Validator("BASE_IMAGE",
must_exist=False,
env=settings.ENV_FOR_DYNACONF),
),
Validator(
"PORT",
must_exist=True,
ne=8000,
when=Validator("MYSQL_HOST", eq="localhost"),
),
#
Validator("ZERO", is_type_of=int, eq=0),
Validator("FALSE", is_type_of=bool, eq=False),
)
assert settings.validators.validate() is None
settings.validators.register(
Validator("TESTVALUEZZ", env="development"),
Validator("TESTVALUE", eq="hello_world"),
)
with pytest.raises(ValidationError):
settings.validators.validate()
with pytest.raises(TypeError):
Validator("A", condition=1)
with pytest.raises(TypeError):
Validator("A", when=1)
def test_from_env_method(clean_env, tmpdir):
data = {
"default": {
"a_default": "From default env"
},
"development": {
"value": "From development env",
"only_in_development": True,
},
"other": {
"value": "From other env",
"only_in_other": True
},
}
toml_path = str(tmpdir.join("base_settings.toml"))
toml_loader.write(toml_path, data, merge=False)
settings = LazySettings(settings_file=toml_path, environments=True)
settings.set("ARBITRARY_KEY", "arbitrary value")
assert settings.VALUE == "From development env"
assert settings.A_DEFAULT == "From default env"
assert settings.ONLY_IN_DEVELOPMENT is True
assert settings.ARBITRARY_KEY == "arbitrary value"
assert settings.get("ONLY_IN_OTHER") is None
# clone the settings object pointing to a new env
other_settings = settings.from_env("other")
assert other_settings.VALUE == "From other env"
assert other_settings.A_DEFAULT == "From default env"
assert other_settings.ONLY_IN_OTHER is True
assert other_settings.get("ARBITRARY_KEY") is None
assert other_settings.get("ONLY_IN_DEVELOPMENT") is None
with pytest.raises(AttributeError):
# values set programatically are not cloned
other_settings.ARBITRARY_KEY
with pytest.raises(AttributeError):
# values set only in a specific env not cloned
other_settings.ONLY_IN_DEVELOPMENT
# assert it is cached not created twice
assert other_settings is settings.from_env("other")
# Now the same using keep=True
other_settings = settings.from_env("other", keep=True)
assert other_settings.VALUE == "From other env"
assert other_settings.A_DEFAULT == "From default env"
assert other_settings.ONLY_IN_OTHER is True
assert other_settings.ONLY_IN_DEVELOPMENT is True
assert settings.ARBITRARY_KEY == "arbitrary value"
# assert it is created not cached
assert other_settings is not settings.from_env("other")
# settings remains the same
assert settings.VALUE == "From development env"
assert settings.A_DEFAULT == "From default env"
assert settings.ONLY_IN_DEVELOPMENT is True
assert settings.ARBITRARY_KEY == "arbitrary value"
assert settings.get("ONLY_IN_OTHER") is None
# additional kwargs
data = {
"default": {
"a_default": "From default env"
},
"production": {
"value": "From prod env",
"only_in_prod": True
},
"other": {
"value": "From other env",
"only_in_other": True
},
}
toml_path = str(tmpdir.join("other_settings.toml"))
toml_loader.write(toml_path, data, merge=False)
new_other_settings = other_settings.from_env(
"production", keep=True, SETTINGS_FILE_FOR_DYNACONF=toml_path)
# production values
assert new_other_settings.VALUE == "From prod env"
assert new_other_settings.ONLY_IN_PROD is True
# keep=True values
assert new_other_settings.ONLY_IN_OTHER is True
assert new_other_settings.ONLY_IN_DEVELOPMENT is True
assert settings.A_DEFAULT == "From default env"
from pathlib import Path
from dynaconf import LazySettings
# Tell dynaconf to search in folder of this conf.py file first
config = LazySettings(ROOT_PATH_FOR_DYNACONF=Path(__file__).parent,
CORE_LOADERS_FOR_DYNACONF=('TOML', ),
SETTINGS_FILE_FOR_DYNACONF=('settings.toml',
'.secrets.toml'))
config.DATABASES = {
'default': {
'engine': 'tortoise.backends.asyncpg',
'credentials': {
'host': None,
'port': 0,
'user': None,
'password': None,
'database': config.DB_NAME,
}
},
}
