def arr(
values: Optional[Mapping[str, str]],
default_environ_getter: Callable[[], EnvVarDict],
symbols: Optional[SymbolTable] = None,
) -> Arrangement:
return Arrangement.setup_phase_aware(
symbols=symbols,
process_execution_settings=proc_exe_env_for_test(environ=values, ),
default_environ_getter=default_environ_getter,
setup_settings=None,
)
def test_constant_string_value__current_is_not_none(self):
# ACT & ASSERT #
var = NameAndValue('name', 'value')
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self, SetVariableArgumentsAbsStx.of_nav(var, phase_spec=None),
Arrangement.setup_phase_aware(
process_execution_settings=proc_exe_env_for_test(environ={})),
MultiSourceExpectation.setup_phase_aware(
main_result=asrt.is_none,
main_side_effect_on_environment_variables=asrt.equals(
{var.name: var.value})))
def test_value_SHOULD_be_able_to_have_symbol_references(self):
# ARRANGE #
variable_name = 'variable_to_assign'
my_symbol = StringConstantSymbolContext('my_symbol', 'my symbol value')
your_symbol = StringConstantSymbolContext('your_symbol',
'your symbol value')
value_template = 'pre {MY_SYMBOL} {YOUR_SYMBOL} post'
expected_evaluated_value_string = value_template.format(
MY_SYMBOL=my_symbol.str_value,
YOUR_SYMBOL=your_symbol.str_value,
)
expected_environ_after_main = {
variable_name: expected_evaluated_value_string,
}
value_source_string = value_template.format(
MY_SYMBOL=symbol_reference_syntax_for_name(my_symbol.name),
YOUR_SYMBOL=symbol_reference_syntax_for_name(your_symbol.name),
)
source_syntax = SetVariableArgumentsAbsStx.of_str(
variable_name,
value_source_string,
phase_spec=None,
quoting=QuoteType.SOFT)
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
source_syntax,
Arrangement.setup_phase_aware(
symbols=SymbolContext.symbol_table_of_contexts(
[my_symbol, your_symbol]),
process_execution_settings=ProcessExecutionSettings.
with_environ({}),
),
MultiSourceExpectation.setup_phase_aware(
main_side_effect_on_environment_variables=asrt.equals(
expected_environ_after_main),
symbol_usages=asrt.matches_sequence([
my_symbol.usage_assertion__w_str_rendering,
your_symbol.usage_assertion__w_str_rendering,
]),
),
)
def test_multi_line_value(self):
# ARRANGE #
var = NameAndValue('name', 'a\nmulti\nline\nvalue\n')
environ__before = {}
environ__after = {var.name: var.value}
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx.of_str(var.name,
var.value,
phase_spec=None,
quoting=QuoteType.HARD),
Arrangement.setup_phase_aware(
process_execution_settings=proc_exe_env_for_test(
environ=environ__before)),
MultiSourceExpectation.setup_phase_aware(
main_result=asrt.is_none,
main_side_effect_on_environment_variables=asrt.equals(
environ__after)))
def test_current_environ_is_none(self):
# ACT & ASSERT #
var_in_default = NameAndValue('var_in_default',
'value of var in default')
def get_default_environ() -> Dict[str, str]:
return NameAndValue.as_dict([var_in_default])
var_to_set = NameAndValue('var_to_set', 'value')
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self, SetVariableArgumentsAbsStx.of_nav(var_to_set,
phase_spec=None),
Arrangement.setup_phase_aware(
process_execution_settings=proc_exe_env_for_test(environ=None),
default_environ_getter=get_default_environ,
),
MultiSourceExpectation.setup_phase_aware(
main_result=asrt.is_none,
main_side_effect_on_environment_variables=asrt.equals(
NameAndValue.as_dict([var_in_default, var_to_set]))))
def test_WHEN_env_contains_the_var_being_set_THEN_its_value_SHOULD_be_replaced(
self):
# ACT & ASSERT #
var_name = 'ENV_VAR'
value_before = 'before'
value_after = 'after'
environ__before = {var_name: value_before}
environ__after = {var_name: value_after}
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx.of_str(var_name,
value_after,
phase_spec=None),
Arrangement.setup_phase_aware(
process_execution_settings=proc_exe_env_for_test(
environ=environ__before)),
MultiSourceExpectation.setup_phase_aware(
main_result=asrt.is_none,
main_side_effect_on_environment_variables=asrt.equals(
environ__after)))
def runTest(self):
# ACT & ASSERT #
name = StringLiteralAbsStx('name')
for phase_spec in PHASE_SPECS:
for validation_case in str_src_validation_cases.failing_validation_cases(
):
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx(name,
validation_case.value.syntax,
phase_spec=phase_spec),
Arrangement.setup_phase_aware(
symbols=validation_case.value.symbol_context.
symbol_table),
MultiSourceExpectation.setup_phase_aware(
symbol_usages=validation_case.value.symbol_context.
usages_assertion,
validation=validation_case.value.assertion,
),
sub_test_identifiers={
'phase_spec': phase_spec,
'validation_case': validation_case.name,
})
