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]