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 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 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_not_set(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = RedisRequirement(registry=PluginRegistry(),
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_empty_variable_treated_as_unset():
requirement = EnvVarRequirement(registry=PluginRegistry(), 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.logs
assert [] == status.errors
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_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 _do_nothing(stage):
stage.set_result(
PrepareSuccess(logs=[],
statuses=(),
command_exec_info=None,
environ=dict(),
overrides=UserConfigOverrides()),
[])
return 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 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 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 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 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 last(stage):
assert state['state'] == 'first'
state['state'] = 'second'
stage.set_result(
PrepareFailure(logs=[],
statuses=(),
errors=[],
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_not_set(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
requirement = DownloadRequirement(registry=PluginRegistry(),
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_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 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 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 config_html(dirname):
FILENAME = os.path.join(dirname, 'data.csv')
local_state_file = LocalStateFile.load_for_directory(dirname)
requirement = _download_requirement()
environ = minimal_environ(PROJECT_DIR=dirname)
status = requirement.check_status(environ, local_state_file, 'default',
UserConfigOverrides())
provider = DownloadProvider()
html = provider.config_html(requirement, environ, local_state_file,
UserConfigOverrides(), status)
assert 'Download {} to {}'.format(requirement.url,
requirement.filename) in html
with open(FILENAME, 'w') as f:
f.write('boo')
env = minimal_environ(PROJECT_DIR=dirname)
status = requirement.check_status(env, local_state_file, 'default',
UserConfigOverrides())
html = provider.config_html(requirement, env, local_state_file,
UserConfigOverrides(), status)
expected_choice = 'Use already-downloaded file {}'.format(FILENAME)
assert expected_choice in html
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 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 downloaded_file_valid(dirname):
local_state = LocalStateFile.load_for_directory(dirname)
filename = os.path.join(dirname, 'data.zip')
requirement = DownloadRequirement(registry=PluginRegistry(),
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=PluginRegistry(),
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 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'
