class ValueWSymRefsAndVarRefs:
REFERENCED_VAR_1 = NameAndValue('existing_var_1', '<val of existing 1>')
REFERENCED_VAR_2 = NameAndValue('existing_var_2', '<val of existing 2>')
REFERENCED_VAR__ALL = [REFERENCED_VAR_1, REFERENCED_VAR_2]
VALUE_PATTERN = '{}between{}'
VALUE_W_VAR_REFS = VALUE_PATTERN.format(
env_var_ref_syntax(REFERENCED_VAR_1.name),
env_var_ref_syntax(REFERENCED_VAR_2.name),
)
VALUE_WO_VAR_REFS = VALUE_PATTERN.format(
REFERENCED_VAR_1.value,
REFERENCED_VAR_2.value,
)
POS_OF_END_OF_VAR_REF_1 = end_of_1st_var_ref(VALUE_W_VAR_REFS)
SYM_REF_PART_1 = StringConstantSymbolContext(
'VAL_SYM_1',
VALUE_W_VAR_REFS[:4],
default_restrictions=asrt_w_str_rend_rest.is__w_str_rendering(),
)
CONST_STR_PART_2 = VALUE_W_VAR_REFS[4:(POS_OF_END_OF_VAR_REF_1 + 5)]
SYM_REF_PART_3 = StringConstantSymbolContext(
'VAL_SYM_3',
VALUE_W_VAR_REFS[(POS_OF_END_OF_VAR_REF_1 + 5):],
default_restrictions=asrt_w_str_rend_rest.is__w_str_rendering(),
)
SYMBOL_CONTEXTS = (SYM_REF_PART_1, SYM_REF_PART_3)
STRING_ABS_STX = str_abs_stx.StringConcatAbsStx([
SYM_REF_PART_1.abstract_syntax,
str_abs_stx.StringLiteralAbsStx(CONST_STR_PART_2),
SYM_REF_PART_3.abstract_syntax,
])
def test_a_references_to_a_non_existing_env_var_SHOULD_be_replaced_with_empty_string(
self):
# ARRANGE #
existing_var = NameAndValue('existing', 'EXISTING')
non_existing_var__name = 'non_existing'
new_var_to_set__name = 'new_var_to_set'
source = SetVariableArgumentsAbsStx.of_str(
new_var_to_set__name,
env_var_ref_syntax(non_existing_var__name),
phase_spec=None,
)
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self, source,
Arrangement.setup_phase_aware(
process_execution_settings=proc_exe_env_for_test(
environ={existing_var.name: existing_var.value})),
MultiSourceExpectation.setup_phase_aware(
main_result=asrt.is_none,
main_side_effect_on_environment_variables=asrt.equals({
existing_var.name:
existing_var.value,
new_var_to_set__name:
'',
})))
def test_set_value_that_references_an_env_var(self):
# ARRANGE #
existing_env_var = NameAndValue('MY_VAR', 'MY_VAL')
defined_env_var = NameAndValue('name', existing_env_var.value)
environ__before = {
existing_env_var.name: existing_env_var.value,
}
environ__after = {
defined_env_var.name: defined_env_var.value,
existing_env_var.name: existing_env_var.value,
}
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx.of_str(defined_env_var.name,
env_var_ref_syntax(
existing_env_var.name),
phase_spec=None),
arrangement=Arrangement.setup_phase_aware(
process_execution_settings=ProcessExecutionSettings.
with_environ(environ__before), ),
expectation=MultiSourceExpectation.setup_phase_aware(
main_side_effect_on_environment_variables=asrt.equals(
environ__after), ))
def test_set_value_that_contains_text_and_references_to_env_vars(self):
# ARRANGE #
my_var = NameAndValue('MY_VAR', 'MY_VAL')
your_var = NameAndValue('YOUR_VAR', 'YOUR_VAL')
var_to_set_name = 'name'
value_template = 'pre {my_var} {your_var} post'
source = SetVariableArgumentsAbsStx.of_str(
var_to_set_name,
value_template.format(
my_var=env_var_ref_syntax(my_var.name),
your_var=env_var_ref_syntax(your_var.name),
),
phase_spec=None,
quoting=QuoteType.SOFT,
)
expected_value = value_template.format(
my_var=my_var.value,
your_var=your_var.value,
)
environ__before = {
my_var.name: my_var.value,
your_var.name: your_var.value,
}
expected_environ__after = {
var_to_set_name: expected_value,
my_var.name: my_var.value,
your_var.name: your_var.value,
}
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
source,
arrangement=Arrangement.setup_phase_aware(
process_execution_settings=ProcessExecutionSettings.
with_environ(environ__before), ),
expectation=MultiSourceExpectation.setup_phase_aware(
main_side_effect_on_environment_variables=asrt.equals(
expected_environ__after), ))
def test_reference_should_be_resolved_in_manipulated_phase(self):
common_var_name = 'existing_in_both_act_and_non_act'
new_var_to_set = NameAndValue('name_of_var_to_set',
env_var_ref_syntax(common_var_name))
common_var_value = {
Phase.NON_ACT: 'value of common var in non act',
Phase.ACT: 'value of common var in act',
}
before_modification = EnvironsSetupForSet(
non_act=[
NameAndValue(common_var_name, common_var_value[Phase.NON_ACT]),
NameAndValue('only_in_non_act',
'value of var only in non-act'),
],
the_act=[
NameAndValue(common_var_name, common_var_value[Phase.ACT]),
NameAndValue('only_in_act', 'value of var only in act'),
],
)
after_modification = before_modification.new_with_added(
non_act=NameAndValue(new_var_to_set.name,
common_var_value[Phase.NON_ACT]),
the_act=NameAndValue(new_var_to_set.name,
common_var_value[Phase.ACT]),
)
all_execution_cases = _exe_cases_of_modification(
before_modification, after_modification)
# ACT & ASSERT #
CHECKER.check__abs_stx__multi__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx.of_nav(new_var_to_set, phase_spec=None),
symbol_usages=asrt.is_empty_sequence,
execution_cases=all_execution_cases,
)
def test_set_value_that_references_an_env_var_in_string_ref_value(self):
# ARRANGE #
existing_env_var = NameAndValue('MY_VAR', 'MY_VAL')
defined_env_var = NameAndValue('name', existing_env_var.value)
source_string_symbol_w_env_var_ref = StringSourceSymbolContext.of_primitive_constant(
'SYMBOL_W_ENV_VAR_REF', env_var_ref_syntax(existing_env_var.name))
environ__before = {
existing_env_var.name: existing_env_var.value,
}
environ__after = {
defined_env_var.name: defined_env_var.value,
existing_env_var.name: existing_env_var.value,
}
# ACT & ASSERT #
CHECKER.check__abs_stx__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx(
StringLiteralAbsStx(defined_env_var.name),
source_string_symbol_w_env_var_ref.abstract_syntax,
phase_spec=None),
arrangement=Arrangement.setup_phase_aware(
symbols=source_string_symbol_w_env_var_ref.symbol_table,
process_execution_settings=ProcessExecutionSettings.
with_environ(environ__before),
),
expectation=MultiSourceExpectation.setup_phase_aware(
symbol_usages=source_string_symbol_w_env_var_ref.
references_assertion,
main_side_effect_on_environment_variables=asrt.equals(
environ__after),
))
def test_reference_should_be_resolved_in_the_manipulated_phase(self):
existing_var = NameAndValue('existing_name', 'value of existing')
new_var_to_set_w_ref = NameAndValue(
'name_of_var_to_set', env_var_ref_syntax(existing_var.name))
vars_before = [existing_var]
execution_cases = _exe_cases_of_modification(
before_modification=vars_before,
after_modification=[
existing_var,
NameAndValue(new_var_to_set_w_ref.name, existing_var.value)
])
# ACT & ASSERT #
for phase_spec__source in [None, Phase.NON_ACT]:
CHECKER.check__abs_stx__multi__std_layouts_and_source_variants(
self,
SetVariableArgumentsAbsStx.of_nav(
new_var_to_set_w_ref, phase_spec=phase_spec__source),
symbol_usages=asrt.is_empty_sequence,
execution_cases=execution_cases,
sub_test_identifiers={
'phase_spec__source': phase_spec__source,
},
)