def test_validate_all(tmpdir):
"""Assert custom message is being processed by validator."""
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(environments=True,
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}),
Validator("BLABLABLA", must_exist=True),
)
with pytest.raises(ValidationError) as error:
settings.validators.validate_all()
assert (custom_msg.format(name="VERSION", value="1", env="DEVELOPMENT")
in error.value.message)
assert "BLABLABLA" in error.value.message
assert error.type == ValidationError
assert len(error.value.details) == 2
def __init__(self):
if not TEST_INSTANCE:
settings = Dynaconf(
settings_files=[tkb_default_file, tkb_file],
envvar_prefix="TKB",
validators=[
Validator("data_path", must_exist=True),
Validator("rebuild_features",
condition=is_bool,
default=False),
Validator("enable_tensorflow",
condition=is_bool,
default=True),
],
)
try:
settings.validators.validate()
except validator.ValidationError as e:
print("Error in configuration:", e)
exit(1)
self.DATA_PATH = settings.data_path
self.REBUILD_FEATURES = settings.REBUILD_FEATURES
self.ENABLE_TENSORFLOW = settings.enable_tensorflow
else:
self.DATA_PATH = DATA_PATH
self.REBUILD_FEATURES = REBUILD_FEATURES
self.ENABLE_TENSORFLOW = ENABLE_TENSORFLOW
def validate_config(config: Settings):
"""
Validates the given Dynaconf object. Throws if the config is invalid.
"""
validators = [
Validator("logging.console", is_type_of=bool, required=True, eq=True)
| Validator("logging.file", is_type_of=bool, required=True, eq=True),
Validator(
"logging.console_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
required=True,
when=Validator("logging.console", eq=True),
),
Validator(
"logging.file_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
required=True,
when=Validator("logging.file", eq=True),
),
Validator("logging.filename",
required=True,
when=Validator("logging.file", eq=True)),
Validator("threatbus", required=True),
Validator("snapshot", is_type_of=int, required=True),
]
config.validators.register(*validators)
config.validators.validate()
def test_negative_combined_and_validators(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True)
settings.validators.register(
Validator("VERSION", ne=1) & Validator("VERSION", ne=1), )
with pytest.raises(ValidationError):
settings.validators.validate()
def test_positive_combined_validators(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True)
settings.validators.register(
Validator("VERSION", ne=1) | Validator("VERSION", ne=2),
Validator("VERSION", ne=4) & Validator("VERSION", ne=2),
)
settings.validators.validate()
def config_validators() -> List[Validator]:
return [
Validator(f"plugins.backbones.{plugin_name}.input_file",
required=True),
Validator(
f"plugins.backbones.{plugin_name}.repetitions",
is_type_of=int,
required=True,
),
]
def validate_config(config: Settings):
"""
Validates the given Dynaconf object. Throws if the config is invalid.
"""
validators = [
Validator("logging.console", is_type_of=bool, default=True),
Validator("logging.file", is_type_of=bool, default=False),
Validator(
"logging.console_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
default="INFO",
),
Validator(
"logging.file_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
default="INFO",
),
Validator("logging.filename", default="suricata-threatbus.log"),
Validator("threatbus", default="localhost:13370"),
Validator("socket", "rules_file", required=True),
Validator("snapshot", is_type_of=int, default=30),
Validator("reload_interval", is_type_of=int, default=60),
]
config.validators.register(*validators)
config.validators.validate()
def config_validators() -> List[Validator]:
return [
Validator(f"plugins.apps.{plugin_name}.host", required=True),
Validator(
f"plugins.apps.{plugin_name}.manage",
f"plugins.apps.{plugin_name}.pub",
f"plugins.apps.{plugin_name}.sub",
is_type_of=int,
required=True,
),
]
def initialise_settings() -> None:
"""Configure and validates settings.
This method is called when starting the microservice to ensure all configuration settings are properly provided.
Raises:
:class:`~dynaconf.validator.ValidationError`: A setting is not valid.
"""
not_doc = Validator("ENV_FOR_DYNACONF", is_not_in=["documentation"])
settings.configure(ENVVAR_PREFIX_FOR_DYNACONF="OEO")
utils = SettingValidationUtils()
settings.validators.register(
Validator(SettingKeys.OPENEO_VERSION.value,
must_exist=True,
when=not_doc),
Validator(SettingKeys.SECRETE_KEY.value, must_exist=True,
when=not_doc),
Validator(SettingKeys.UPLOAD_TMP_DIR.value,
must_exist=True,
condition=utils.check_create_folder,
when=not_doc),
Validator(SettingKeys.RABBIT_HOST.value, must_exist=True,
when=not_doc),
Validator(SettingKeys.RABBIT_PORT.value,
must_exist=True,
is_type_of=int,
when=not_doc),
Validator(SettingKeys.RABBIT_USER.value, must_exist=True,
when=not_doc),
Validator(SettingKeys.RABBIT_PASSWORD.value,
must_exist=True,
when=not_doc),
)
settings.validators.validate()
def test_envless_and_combined_validators(tmpdir):
tmpfile = tmpdir.join("settings.toml")
TOML = """
value = true
version = 1
name = 'Bruno'
"""
tmpfile.write(TOML)
settings = LazySettings(SETTINGS_FILE_FOR_DYNACONF=str(tmpfile),
silent=True)
settings.validators.register(
Validator("VERSION", ne=1) & Validator("value", ne=True), )
with pytest.raises(ValidationError):
settings.validators.validate()
def test_validators_on_init(tmpdir):
TOML = """
[default]
hostname = 'devserver.com'
username = '******'
"""
tmpdir.join("settings.toml").write(TOML)
settings = LazySettings(validators=(
Validator("hostname", eq="devserver.com"),
Validator("username", ne="admin"),
))
with pytest.raises(ValidationError):
settings.validators.validate()
def yaml_validators_good():
return [
Validator("server.hostname",
"server.port",
"server.users",
must_exist=True),
Validator(
"app.name",
"app.path",
"app.args.arg1",
"app.args.arg2",
"app.args.arg3",
must_exist=True,
),
]
def test_dotted_validators(settings):
settings.set(
"PARAMS",
{"PASSWORD": "******", "SSL": {"CONTEXT": "SECURE", "ENABLED": True}},
)
settings.validators.register(
Validator("PARAMS", must_exist=True, is_type_of=dict),
Validator("PARAMS.PASSWORD", must_exist=True, is_type_of=str),
Validator("PARAMS.SSL", must_exist=True, is_type_of=dict),
Validator("PARAMS.SSL.ENABLED", must_exist=True, is_type_of=bool),
Validator("PARAMS.NONEXISTENT", must_exist=False, is_type_of=str),
)
assert settings.validators.validate() is None
def validate_threatbus_config(config: Settings):
"""
Validates the given Dynaconf object, potentially adding new entries for the default values.
Throws if the config is invalid.
"""
validators = [
Validator("logging.console",
is_type_of=bool,
required=True,
default=True),
Validator("logging.file",
is_type_of=bool,
required=True,
default=False),
Validator(
"logging.console_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
default="INFO",
),
Validator(
"logging.file_verbosity",
is_in=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
default="INFO",
),
Validator(
"logging.filename",
required=True,
when=Validator("logging.file", eq=True, default="threatbus.log"),
),
Validator("plugins.apps", "plugins.backbones", required=True),
]
config.validators.register(*validators)
config.validators.validate()
def config_validators() -> List[Validator]:
return [
Validator(
f"plugins.backbones.{plugin_name}.host",
f"plugins.backbones.{plugin_name}.username",
f"plugins.backbones.{plugin_name}.password",
is_type_of=str,
required=True,
),
Validator(
f"plugins.backbones.{plugin_name}.vhost",
is_type_of=str,
default="/",
),
Validator(
f"plugins.backbones.{plugin_name}.exchange_name",
default="threatbus",
),
Validator(
f"plugins.backbones.{plugin_name}.port",
is_type_of=int,
required=True,
),
Validator(
f"plugins.backbones.{plugin_name}.queue.durable",
f"plugins.backbones.{plugin_name}.queue.lazy",
is_type_of=bool,
default=True,
),
Validator(
f"plugins.backbones.{plugin_name}.queue.auto_delete",
f"plugins.backbones.{plugin_name}.queue.exclusive",
is_type_of=bool,
default=False,
),
Validator(
f"plugins.backbones.{plugin_name}.queue.name_join_symbol",
required=True,
default=".",
),
Validator(
f"plugins.backbones.{plugin_name}.queue.name_suffix",
default=gethostname(),
),
Validator(
f"plugins.backbones.{plugin_name}.queue.max_items",
is_type_of=int,
default=0,
),
]
def test_dotted_validators(settings):
settings.set('PARAMS', {
'PASSWORD': '******',
'SSL': {
'CONTEXT': 'SECURE',
'ENABLED': True
},
})
settings.validators.register(
Validator('PARAMS', must_exist=True, is_type_of=dict),
Validator('PARAMS.PASSWORD', must_exist=True, is_type_of=str),
Validator('PARAMS.SSL', must_exist=True, is_type_of=dict),
Validator('PARAMS.SSL.ENABLED', must_exist=True, is_type_of=bool),
Validator('PARAMS.NONEXISTENT', must_exist=False, is_type_of=str))
assert settings.validators.validate() is None
def config_validators() -> List[Validator]:
return [
Validator(
f"plugins.apps.{plugin_name}.host",
is_type_of=str,
default="localhost",
),
Validator(
f"plugins.apps.{plugin_name}.module_namespace",
is_type_of=str,
default="Tenzir",
),
Validator(
f"plugins.apps.{plugin_name}.port",
is_type_of=int,
default=47761,
),
]
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 configuration():
settings = Dynaconf(
envvar_prefix="TCHESS",
settings_files=['settings.toml'],
load_dotenv=True,
validators = [
Validator('LICHESS.API_KEY', must_exist=True) | Validator('LICHESS.API_KEY_CMD', must_exist=True),
]
)
settings.validators.validate()
if settings.lichess.get("api_key_cmd") and not settings.lichess.get("api_key"):
settings.lichess.api_key = pass_cmd(settings.lichess.api_key_cmd)
return settings
def test_validator_only_current_env_valid(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(
settings_file=str(tmpfile),
environments=True,
ENV_FOR_DYNACONF="DEVELOPMENT",
)
settings.validators.register(
Validator("IMAGE_1", env="production", must_exist=True))
settings.validators.validate(only_current_env=True)
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_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_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 config_validators() -> List[Validator]:
return [
Validator(
f"plugins.apps.{plugin_name}.group",
default="everyone",
),
Validator(
f"plugins.apps.{plugin_name}.tlp",
default="amber",
),
Validator(
f"plugins.apps.{plugin_name}.confidence",
is_type_of=float,
default=7.5,
),
Validator(
f"plugins.apps.{plugin_name}.tags",
is_type_of=list,
required=True,
),
Validator(
f"plugins.apps.{plugin_name}.api.host",
f"plugins.apps.{plugin_name}.api.token",
required=True,
),
Validator(
f"plugins.apps.{plugin_name}.api.ssl",
is_type_of=bool,
required=True,
),
]
def test_raises_only_current_env_invalid(tmpdir):
tmpfile = tmpdir.join("settings.toml")
tmpfile.write(TOML)
settings = LazySettings(
settings_file=str(tmpfile),
environments=True,
ENV_FOR_DYNACONF="PRODUCTION",
)
settings.validators.register(
Validator("IMAGE_1", env="production", must_exist=True))
with pytest.raises(ValidationError):
settings.validators.validate(only_current_env=True)
def test_use_default_value_when_yaml_is_empty_and_explicitly_marked(tmpdir):
tmpfile = tmpdir.join("settings.yaml")
tmpfile.write(YAML)
settings = Dynaconf(
settings_file=str(tmpfile),
validators=[
# Explicitly say thar default must be applied to None
Validator(
"hasemptyvalues.key1",
default="value1",
apply_default_on_none=True,
),
# The following 2 defaults must be ignored
Validator("hasemptyvalues.key2", default="value2"),
Validator("hasemptyvalues.key3", default="value3"),
# This one must be set because on YAML key is set to `@empty`
Validator("hasemptyvalues.key4", default="value4"),
],
)
assert settings.hasemptyvalues.key1 == "value1"
assert settings.hasemptyvalues.key2 is None
assert settings.hasemptyvalues.key3 is None
assert settings.hasemptyvalues.key4 == "value4"
def init_psql(self):
settings.validators.register(
Validator('psql_user', 'psql_pass', must_exist=True))
settings.validators.validate()
self.engine = db.create_engine(
'postgresql+psycopg2://{user}:{password}@{hostname}/{dbname}'.
format(user=settings.PSQL_USER,
password=settings.PSQL_PASS,
hostname=settings.SQL_HOST,
dbname=settings.SQL_DBNAME))
try:
self.connection = self.engine.connect()
self.session = sessionmaker(bind=self.engine)
except OperationalError as e:
logger.exception(e)
self.connection = None
def test_default_eq_env_lvl_1():
"""Tests when the env value equals the default value."""
VAR_NAME = "test"
ENV = "DYNATESTRUN_TEST"
settings = Dynaconf(
environments=False,
envvar_prefix="DYNATESTRUN",
validators=[
Validator(
VAR_NAME,
default=True,
is_type_of=bool,
),
],
)
os.environ[ENV] = "true"
assert settings.test is True
del os.environ[ENV]
def test_equality():
validator1 = Validator("VERSION", "AGE", "NAME", must_exist=True)
validator2 = Validator("VERSION", "AGE", "NAME", must_exist=True)
assert validator1 == validator2
assert validator1 is not validator2
validator3 = (Validator("IMAGE_1",
when=Validator("BASE_IMAGE", must_exist=True)), )
validator4 = (Validator("IMAGE_1",
when=Validator("MYSQL_HOST", must_exist=True)), )
assert validator3 != validator4
def test_default_lvl_2():
"""Tests if the default works propperly with one nested level.
Uses different values for the default and the environment variable.
"""
VAR_NAME = "nested.test"
ENV = "DYNATESTRUN_NESTED__TEST"
settings = Dynaconf(
environments=False,
envvar_prefix="DYNATESTRUN",
validators=[
Validator(
VAR_NAME,
default=True,
is_type_of=bool,
),
],
)
os.environ[ENV] = "false"
assert settings.nested.test is False
del os.environ[ENV]
