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_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 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())
html = RedisProvider().config_html(requirement, result.environ,
local_state_file,
UserConfigOverrides(), status)
assert 'Use the redis-server we started earlier' in html
# 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 do_test(dirname):
io_loop = IOLoop()
io_loop.make_current()
events = []
def event_handler(event):
events.append(event)
project = Project(dirname)
local_state_file = LocalStateFile.load_for_directory(dirname)
requirement = EnvVarRequirement(registry=project.plugin_registry,
env_var="FOO")
status = requirement.check_status(dict(), local_state_file, 'default',
UserConfigOverrides())
context = ConfigurePrepareContext(dict(), local_state_file, 'default',
UserConfigOverrides(), [status])
server = UIServer(project, _no_op_prepare(context), event_handler,
io_loop)
# do a get so that _requirements_by_id below exists
get_response = http_get(io_loop, server.url)
assert 200 == get_response.code
req_id = list(server._application._requirements_by_id.keys())[0]
if '%s' in name_template:
name = name_template % req_id
else:
name = name_template
encoder = MultipartEncoder({name: 'bloop'})
body = encoder.to_string()
headers = {'Content-Type': encoder.content_type}
post_response = http_post(io_loop,
server.url,
body=body,
headers=headers)
# we just ignore bad form names, because they are assumed
# to be some sort of hostile thing. we shouldn't ever
# generate them on purpose.
assert 200 == post_response.code
server.unlisten()
assert len(events) == 1
assert isinstance(events[0], UIServerDoneEvent)
out, err = capsys.readouterr()
assert out == ""
assert err == expected_err
def check_env_var_provider_config(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO")
local_state_file = LocalStateFile.load_for_directory(dirname)
environ = dict()
config = provider.read_config(requirement, environ, local_state_file, 'default', UserConfigOverrides())
assert dict(source='unset') == config
# config html when variable is unset
status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides())
html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status)
assert "Keep" not in html
assert 'Use this value:' in html
# config html when variable is unset and we have a default
requirement.options['default'] = 'from_default'
status = requirement.check_status(dict(), local_state_file, 'default', UserConfigOverrides())
html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status)
assert "Keep default 'from_default'" in html
assert 'Use this value instead:' in html
# config html when variable is set
environ = dict(FOO='from_environ')
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status)
assert "Keep value 'from_environ'" in html
assert 'Use this value instead:' in html
# config html when local state override is present
environ = dict(FOO='from_environ')
local_state_file.set_value(['variables', 'FOO'], 'from_local_state')
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
html = provider.config_html(requirement, environ, local_state_file, UserConfigOverrides(), status)
assert "Keep value 'from_environ'" in html
assert 'Use this value instead:' in html
def do_test(dirname):
io_loop = IOLoop()
io_loop.make_current()
events = []
def event_handler(event):
events.append(event)
local_state_file = LocalStateFile.load_for_directory(dirname)
value = local_state_file.get_value(['variables', 'FOO'])
assert value is None
project = Project(dirname)
requirement = EnvVarRequirement(registry=project.plugin_registry,
env_var="FOO")
status = requirement.check_status(dict(), local_state_file, 'default',
UserConfigOverrides())
context = ConfigurePrepareContext(dict(), local_state_file, 'default',
UserConfigOverrides(), [status])
server = UIServer(project, _no_op_prepare(context), event_handler,
io_loop)
get_response = http_get(io_loop, server.url)
print(repr(get_response))
soup = BeautifulSoup(get_response.body, _BEAUTIFUL_SOUP_BACKEND)
field = soup.find_all("input", attrs={'type': 'text'})[0]
assert 'name' in field.attrs
encoder = MultipartEncoder({field['name']: 'bloop'})
body = encoder.to_string()
headers = {'Content-Type': encoder.content_type}
post_response = http_post(io_loop,
server.url,
body=body,
headers=headers)
print(repr(post_response))
server.unlisten()
assert len(events) == 1
assert isinstance(events[0], UIServerDoneEvent)
value = local_state_file.get_value(['variables', 'FOO'])
assert 'bloop' == value
def do_test(dirname):
io_loop = IOLoop()
io_loop.make_current()
events = []
def event_handler(event):
events.append(event)
project = Project(dirname)
local_state_file = LocalStateFile.load_for_directory(dirname)
context = ConfigurePrepareContext(dict(), local_state_file, 'default',
UserConfigOverrides(), [])
server = UIServer(project, _no_op_prepare(context), event_handler,
io_loop)
get_response = http_get(io_loop, server.url)
print(repr(get_response))
post_response = http_post(io_loop, server.url, body="")
print(repr(post_response))
server.unlisten()
assert len(events) == 1
assert isinstance(events[0], UIServerDoneEvent)
def _do_nothing(stage):
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()), [])
return None
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 test_prepare_success_properties():
result = PrepareSuccess(logs=["a"],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides())
assert result.statuses == ()
assert result.status_for('FOO') is None
assert result.status_for(EnvVarRequirement) is None
assert result.overrides is not None
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 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_bad_scheme(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=PluginRegistry(), 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 last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(logs=[],
statuses=(),
errors=[],
environ=dict(),
overrides=UserConfigOverrides()),
[])
return None
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
return None
def _no_op_prepare(config_context):
def _do_nothing(stage):
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()), [])
return None
return _FunctionPrepareStage(dict(), UserConfigOverrides(), "Do Nothing",
[], _do_nothing, config_context)
def check_missing_package(dirname):
requirement = CondaEnvRequirement(
registry=PluginRegistry(),
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 check_provide_contents(dirname):
environ = dict(foo='bar')
local_state_file = LocalStateFile.load_for_directory(dirname)
requirement = EnvVarRequirement(PluginRegistry(), 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)
assert dict(foo='bar') == context.environ
assert context.status is status
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_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)
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(PluginRegistry(), 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)
with pytest.raises(IOError) as excinfo:
context.ensure_service_directory("foo")
assert "this is not EEXIST" in repr(excinfo.value)
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 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 do_first(stage):
assert state['state'] == 'start'
state['state'] = 'first'
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(logs=[],
statuses=(),
errors=[],
environ=dict(),
overrides=UserConfigOverrides()),
[])
return None
return _FunctionPrepareStage(dict(), UserConfigOverrides(), "second", [], last)
def check_cannot_connect(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=PluginRegistry(), 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_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)
result = provider.provide(requirement, context=context)
assert [] == result.errors
assert 'FOO' in context.environ
assert 'from_environ' == context.environ['FOO']
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(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
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
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 not result.failed
assert state['state'] == 'after'
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(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
def last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(logs=[],
statuses=(),
errors=[],
environ=dict(),
overrides=UserConfigOverrides()),
[])
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_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)
result = provider.provide(requirement, context=context)
assert [] == result.errors
assert 'FOO_SECRET' in context.environ
assert 'from_default' == context.environ['FOO_SECRET']
def check_env_var_provider(dirname):
provider = EnvVarProvider()
requirement = _load_env_var_requirement(dirname, "FOO_PASSWORD")
assert requirement.encrypted
local_state_file = LocalStateFile.load_for_directory(dirname)
# set in environ to be sure we override it with local state
environ = dict(FOO_PASSWORD='******')
status = requirement.check_status(environ, local_state_file, 'default', UserConfigOverrides())
assert dict(value="from_local_state", source="variables") == status.analysis.config
context = ProvideContext(environ=environ,
local_state_file=local_state_file,
default_env_spec_name='default',
status=status,
mode=PROVIDE_MODE_DEVELOPMENT)
result = provider.provide(requirement, context=context)
assert [] == result.errors
assert 'FOO_PASSWORD' in context.environ
assert 'from_local_state' == context.environ['FOO_PASSWORD']
