def check_env_var_provider_config_local_state(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO_PASSWORD")
assert requirement.encrypted
local_state_file = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides())
assert dict(source='unset') == status.analysis.config
assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None
assert set(keyring.fallback_data().values()) == set()
environ = dict(CONDA_DEFAULT_ENV='/pretend/env', CONDA_ENV_PATH='/pretend/env', CONDA_PREFIX='/pretend/env')
provider.set_config_values_as_strings(requirement,
environ,
local_state_file,
'default',
UserConfigOverrides(),
dict(value="bar"))
# should not have affected local state, should use keyring
assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None
assert set(keyring.fallback_data().values()) == set(["bar"])
# setting empty string = unset
provider.set_config_values_as_strings(requirement,
environ,
local_state_file,
'default',
UserConfigOverrides(),
dict(value=""))
assert local_state_file.get_value(['variables', 'FOO_PASSWORD']) is None
assert set(keyring.fallback_data().values()) == set()
def check_env_var_provider_config_disabled_local_state(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO")
local_state_file = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides())
assert dict(source='unset') == status.analysis.config
assert local_state_file.get_value(['variables', 'FOO']) is None
assert local_state_file.get_value(['disabled_variables', 'FOO']) is None
environ = dict()
# source=environ should mean we set disabled_variables instead of variables
provider.set_config_values_as_strings(requirement,
environ,
local_state_file,
'default',
UserConfigOverrides(),
dict(source='environ',
value="bar"))
assert local_state_file.get_value(['variables', 'FOO']) is None
assert local_state_file.get_value(['disabled_variables', 'FOO']) == "bar"
config = provider.read_config(requirement, environ, local_state_file, 'default', UserConfigOverrides())
assert config == dict(source='unset', value='bar')
def check_env_var_provider_config_local_state(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO")
local_state_file = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(dict(), local_state_file, 'default',
UserConfigOverrides())
assert dict(source='unset') == status.analysis.config
assert local_state_file.get_value(['variables', 'FOO']) is None
environ = dict()
provider.set_config_values_as_strings(requirement, environ,
local_state_file, 'default',
UserConfigOverrides(),
dict(value="bar"))
assert local_state_file.get_value(['variables', 'FOO']) == "bar"
local_state_file.save()
local_state_file_2 = LocalStateFile.load_for_directory(dirname)
assert local_state_file_2.get_value(['variables', 'FOO']) == "bar"
# setting empty string = unset
provider.set_config_values_as_strings(requirement, environ,
local_state_file, 'default',
UserConfigOverrides(),
dict(value=""))
assert local_state_file.get_value(['variables', 'FOO']) is None
local_state_file.save()
local_state_file_3 = LocalStateFile.load_for_directory(dirname)
assert local_state_file_3.get_value(['variables', 'FOO']) is None
def prepare_after_setting_scope(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = _redis_requirement()
provider = RedisProvider()
environ = minimal_environ()
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'find_all'
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='find_project'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'find_project'
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='find_all'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'find_all'
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='environ'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'find_all' # default if no env var set
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='environ'))
environ_with_redis_url = environ.copy()
environ_with_redis_url['REDIS_URL'] = 'blah'
config = provider.read_config(requirement, environ_with_redis_url, local_state, 'default',
UserConfigOverrides())
assert config['source'] == 'environ' # default when the env var IS set
# use local variable when env var not set
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='variables', value='foo'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'variables'
assert config['value'] == 'foo'
# use local variable when env var _is_ set
provider.set_config_values_as_strings(requirement, environ_with_redis_url, local_state, 'default',
UserConfigOverrides(), dict(source='variables', value='foo'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'variables'
assert config['value'] == 'foo'
# set to use system, which should override using the local state
provider.set_config_values_as_strings(requirement, environ, local_state, 'default', UserConfigOverrides(),
dict(source='find_system'))
config = provider.read_config(requirement, environ, local_state, 'default', UserConfigOverrides())
assert config['source'] == 'find_system'
project = project_no_dedicated_env(dirname)
result = _prepare_printing_errors(project, environ=minimal_environ())
assert result
assert dict(
REDIS_URL="redis://localhost:6379", PROJECT_DIR=project.directory_path) == strip_environ(result.environ)
assert dict(host='localhost', port=6379, timeout_seconds=0.5) == can_connect_args
def check_provide_contents(dirname):
environ = dict()
local_state_file = LocalStateFile.load_for_directory(dirname)
local_state_file.set_service_run_state("myservice", dict(port=42))
requirement = EnvVarRequirement(RequirementsRegistry(), env_var="FOO")
status = requirement.check_status(environ, local_state_file, 'default',
UserConfigOverrides())
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
def transform_it(state):
assert 42 == state['port']
state['port'] = 43
state['foo'] = 'bar'
return 1234
result = context.transform_service_run_state("myservice", transform_it)
assert 1234 == result
assert dict(
port=43,
foo='bar') == local_state_file.get_service_run_state("myservice")
def read_config(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = _redis_requirement()
provider = RedisProvider()
config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides())
assert 6380 == config['lower_port']
assert 6449 == config['upper_port']
def check_bad_scheme(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=RequirementsRegistry(), env_var="REDIS_URL")
status = requirement.check_status(dict(REDIS_URL="http://example.com/"), local_state, 'default',
UserConfigOverrides())
assert not status
assert "REDIS_URL value 'http://example.com/' does not have 'redis:' scheme." == status.status_description
def test_requirement_status_repr():
requirement = EnvVarRequirement(registry=RequirementsRegistry(),
env_var='FOO')
status = requirement.check_status(dict(FOO=''), tmp_local_state_file(),
'default', UserConfigOverrides())
assert "RequirementStatus(False,'Environment variable FOO is not set.',EnvVarRequirement(env_var='FOO'))" == repr(
status)
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(
statuses=(), errors=[], environ=dict(), overrides=UserConfigOverrides(), env_spec_name='last'), [])
return None
def test_empty_variable_treated_as_unset():
requirement = EnvVarRequirement(registry=RequirementsRegistry(),
env_var='FOO')
status = requirement.check_status(dict(FOO=''), tmp_local_state_file(),
'default', UserConfigOverrides())
assert not status
assert "Environment variable FOO is not set." == status.status_description
assert [] == status.errors
def check_not_set(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=RequirementsRegistry(),
env_var="REDIS_URL")
status = requirement.check_status(dict(), local_state, 'default',
UserConfigOverrides())
assert not status
assert "Environment variable REDIS_URL is not set." == status.status_description
def test_run_after_success_function_when_second_stage_succeeds():
state = {'state': 'start'}
def do_first(stage):
assert state['state'] == 'start'
state['state'] = 'first'
stage.set_result(
PrepareSuccess(statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='foo'),
[])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareSuccess(statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='bar'),
[])
return None
return _FunctionPrepareStage(dict(), UserConfigOverrides(), "second", [], last)
first_stage = _FunctionPrepareStage(dict(), UserConfigOverrides(), "first", [], do_first)
def after(updated_statuses):
assert state['state'] == 'second'
state['state'] = 'after'
stage = _after_stage_success(first_stage, after)
assert stage.overrides is first_stage.overrides
assert stage.description_of_action == first_stage.description_of_action
assert stage.environ == first_stage.environ
assert stage.statuses_before_execute is first_stage.statuses_before_execute
stage.configure() # checking it doesn't raise
while stage is not None:
next_stage = stage.execute()
if hasattr(stage, '_stage'):
assert stage.statuses_after_execute is stage._stage.statuses_after_execute
assert stage.failed is stage._stage.failed
result = stage.result
if result.failed:
assert stage.failed
break
else:
assert not stage.failed
stage = next_stage
assert not result.failed
assert state['state'] == 'after'
def check_conda_default_env_not_set(dirname):
requirement = _empty_default_requirement()
project_dir_disable_dedicated_env(dirname)
local_state = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(
minimal_environ_no_conda_env(PROJECT_DIR=dirname), local_state,
'default', UserConfigOverrides())
expected = "'{}' doesn't look like it contains a Conda environment yet.".format(
os.path.join(dirname, 'envs', 'default'))
assert expected == status.status_description
def check_conda_default_env_is_bogus(dirname):
requirement = _empty_default_requirement()
project_dir_disable_dedicated_env(dirname)
local_state = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(
minimal_environ_no_conda_env(**{'PROJECT_DIR': dirname}),
local_state, 'default',
UserConfigOverrides(inherited_env="not_a_real_env_anyone_has"))
expected = "'not_a_real_env_anyone_has' doesn't look like it contains a Conda environment yet."
assert expected == status.status_description
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareSuccess(statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='bar'), [])
return None
def start_local_redis(dirname):
project = project_no_dedicated_env(dirname)
result = _prepare_printing_errors(project, environ=minimal_environ())
assert result
assert 'REDIS_URL' in result.environ
local_state_file = LocalStateFile.load_for_directory(dirname)
state = local_state_file.get_service_run_state("REDIS_URL")
assert 'port' in state
port = state['port']
assert dict(REDIS_URL=("redis://localhost:" + str(port)),
PROJECT_DIR=project.directory_path) == strip_environ(
result.environ)
assert len(can_connect_args_list) >= 2
pidfile = os.path.join(dirname, "services/REDIS_URL/redis.pid")
logfile = os.path.join(dirname, "services/REDIS_URL/redis.log")
assert os.path.exists(pidfile)
assert os.path.exists(logfile)
assert real_can_connect_to_socket(host='localhost', port=port)
# be sure we generate the config html that would use the old one
requirement = _redis_requirement()
status = requirement.check_status(result.environ, local_state_file,
'default', UserConfigOverrides())
# now try again, and we should re-use the exact same server
pidfile_mtime = os.path.getmtime(pidfile)
with codecs.open(pidfile, 'r', 'utf-8') as file:
pidfile_content = file.read()
result2 = _prepare_printing_errors(project, environ=minimal_environ())
assert result2
# port should be the same, and set in the environment
assert dict(REDIS_URL=("redis://localhost:" + str(port)),
PROJECT_DIR=project.directory_path) == strip_environ(
result2.environ)
# no new pid file
assert pidfile_mtime == os.path.getmtime(pidfile)
with codecs.open(pidfile, 'r', 'utf-8') as file:
pidfile_content2 = file.read()
assert pidfile_content == pidfile_content2
# now clean it up
status = unprepare(project, result2)
assert status
assert not os.path.exists(pidfile)
assert not real_can_connect_to_socket(host='localhost', port=port)
local_state_file.load()
assert dict() == local_state_file.get_service_run_state("REDIS_URL")
def read_config(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = _redis_requirement()
provider = RedisProvider()
config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides())
# revert to defaults
assert 6380 == config['lower_port']
assert 6449 == config['upper_port']
# should have printed an error
out, err = capsys.readouterr()
assert ("Invalid port_range '%s', should be like '6380-6449'\n" % (port_range)) == err
def do_first(stage):
assert state['state'] == 'start'
state['state'] = 'first'
stage.set_result(
PrepareSuccess(
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='first'), [])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(
statuses=(), errors=[], environ=dict(), overrides=UserConfigOverrides(), env_spec_name='last'), [])
return None
return _FunctionPrepareStage(dict(), UserConfigOverrides(), "second", [], last)
def check_cannot_connect(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=RequirementsRegistry(), env_var="REDIS_URL")
can_connect_args_list = _monkeypatch_can_connect_to_socket_fails(monkeypatch)
status = requirement.check_status(dict(REDIS_URL="redis://example.com:1234/"), local_state, 'default',
UserConfigOverrides())
assert dict(host='example.com', port=1234, timeout_seconds=0.5) == can_connect_args_list[0]
assert dict(host='localhost', port=6379, timeout_seconds=0.5) == can_connect_args_list[1]
assert not status
expected = "Cannot connect to Redis at redis://example.com:1234/."
assert expected == status.status_description
def check_not_set(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = DownloadRequirement(registry=RequirementsRegistry(),
env_var=ENV_VAR,
url='http://example.com',
filename=ENV_VAR)
status = requirement.check_status(dict(PROJECT_DIR=dirname),
local_state, 'default',
UserConfigOverrides())
assert not status
assert "Environment variable {} is not set.".format(
ENV_VAR) == status.status_description
def set_config(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = _redis_requirement()
provider = RedisProvider()
provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(),
dict(lower_port="6001"))
config = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides())
assert config['lower_port'] == 6001
assert config['upper_port'] == 6449
provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(),
dict(upper_port="6700"))
config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides())
assert config2['lower_port'] == 6001
assert config2['upper_port'] == 6700
provider.set_config_values_as_strings(requirement, dict(), local_state, 'default', UserConfigOverrides(),
dict(lower_port="5500", upper_port="6800"))
config2 = provider.read_config(requirement, dict(), local_state, 'default', UserConfigOverrides())
assert config2['lower_port'] == 5500
assert config2['upper_port'] == 6800
def check_missing_package(dirname):
requirement = CondaEnvRequirement(
registry=RequirementsRegistry(),
env_specs=dict(default=EnvSpec(
'default', ['boguspackage', 'boguspackage2'], [])))
project_dir_disable_dedicated_env(dirname)
local_state = LocalStateFile.load_for_directory(dirname)
environ = minimal_environ(PROJECT_DIR=dirname)
status = requirement.check_status(
environ, local_state, 'default',
UserConfigOverrides(inherited_env=environ.get(conda_env_var)))
assert "Conda environment is missing packages: boguspackage, boguspackage2" == status.status_description
def downloaded_file_valid(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
filename = os.path.join(dirname, 'data.zip')
requirement = DownloadRequirement(registry=RequirementsRegistry(),
env_var=ENV_VAR,
url='http://localhost/data.zip',
filename='data.zip')
status = requirement.check_status({
ENV_VAR: filename,
'PROJECT_DIR': dirname
}, local_state, 'default', UserConfigOverrides())
assert status
assert 'File downloaded to {}'.format(filename) == status.status_description
def check_missing_filename(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
filename = '/data.zip'
requirement = DownloadRequirement(registry=RequirementsRegistry(),
env_var=ENV_VAR,
url='http://localhost/data.zip',
filename='data.zip')
status = requirement.check_status({
ENV_VAR: filename,
'PROJECT_DIR': dirname
}, local_state, 'default', UserConfigOverrides())
assert not status
assert 'File not found: {}'.format(filename) == status.status_description
def check_provide_contents(dirname):
environ = dict(foo='bar')
local_state_file = LocalStateFile.load_for_directory(dirname)
requirement = EnvVarRequirement(RequirementsRegistry(), env_var="FOO")
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
assert dict(foo='bar') == context.environ
assert context.status is status
def check_env_var_provider(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO")
local_state_file = LocalStateFile.load_for_directory(dirname)
status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides())
context = ProvideContext(environ=dict(),
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
provider.provide(requirement, context=context)
assert 'FOO' not in context.environ
def check_provide_contents(dirname):
environ = dict()
local_state_file = LocalStateFile.load_for_directory(dirname)
requirement = EnvVarRequirement(RequirementsRegistry(), env_var="FOO")
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
with pytest.raises(IOError) as excinfo:
context.ensure_service_directory("foo")
assert "this is not EEXIST" in repr(excinfo.value)
def test_skip_after_success_function_when_second_stage_fails():
state = {'state': 'start'}
def do_first(stage):
assert state['state'] == 'start'
state['state'] = 'first'
stage.set_result(
PrepareSuccess(statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='first'),
[])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(statuses=(),
errors=[],
environ=dict(),
overrides=UserConfigOverrides(),
env_spec_name='last'),
[])
return None
return _FunctionPrepareStage(dict(), UserConfigOverrides(), "second", [], last)
first_stage = _FunctionPrepareStage(dict(), UserConfigOverrides(), "first", [], do_first)
def after(updated_statuses):
raise RuntimeError("should not have been called")
stage = _after_stage_success(first_stage, after)
assert stage.overrides is first_stage.overrides
assert isinstance(stage.environ, dict)
while stage is not None:
next_stage = stage.execute()
result = stage.result
if result.failed:
assert stage.failed
break
else:
assert not stage.failed
stage = next_stage
assert result.failed
assert state['state'] == 'second'
def check_env_var_provider(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO")
local_state_file = LocalStateFile.load_for_directory(dirname)
environ = dict(FOO='from_environ')
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
assert dict(source='environ', value='from_environ') == status.analysis.config
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
result = provider.provide(requirement, context=context)
assert [] == result.errors
assert 'FOO' in context.environ
assert 'from_environ' == context.environ['FOO']
def check_env_var_provider(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO_SECRET")
assert requirement.encrypted
assert dict(default='from_default') == requirement.options
local_state_file = LocalStateFile.load_for_directory(dirname)
environ = dict()
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT,
frontend=NullFrontend())
result = provider.provide(requirement, context=context)
assert [] == result.errors
assert 'FOO_SECRET' in context.environ
assert 'from_default' == context.environ['FOO_SECRET']