def test_target_is_all_phases_or_non_act(self): # ACT & ASSERT # phase_spec__to_check_for_modifications = Phase.NON_ACT environs_setup = EnvironsSetupForSet( the_act=[NameAndValue('act_1', ' value of act_1')], non_act=[NameAndValue('non_act_1', ' value of non_act_1')], ) for phase_spec__source in [None, Phase.NON_ACT]: var_to_set = NameAndValue('var_to_set', 'value_to_set') # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx.of_nav( var_to_set, phase_spec=phase_spec__source), symbol_usages=asrt.is_empty_sequence, execution_cases=[ NArrEx( arr_.name, arr_.value, environs_setup.expectation_of_addition_to_phase( phase_spec__to_check_for_modifications, var_to_set), ) for arr_ in _arr_for( environs_setup, phase_spec__to_check_for_modifications) ], sub_test_identifiers={ 'phase_spec__source': phase_spec__source, }, )
def runTest(self): vars_before = [ ValueWSymRefsAndVarRefs.REFERENCED_VAR_1, ValueWSymRefsAndVarRefs.REFERENCED_VAR_2 ] setup_before = EnvironsSetup(vars_before, vars_before) var_to_set__resolved = NameAndValue( NameWSymRefs.RESOLVED_STR, ValueWSymRefsAndVarRefs.VALUE_WO_VAR_REFS) all_symbols = NameWSymRefs.SYMBOL_CONTEXTS + ValueWSymRefsAndVarRefs.SYMBOL_CONTEXTS execution_cases = _exe_cases_of_modification( before_modification=setup_before, after_modification=setup_before.new_with_added( var_to_set__resolved, var_to_set__resolved), symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ) # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx( NameWSymRefs.STRING_ABS_STX, StringSourceOfStringAbsStx( ValueWSymRefsAndVarRefs.STRING_ABS_STX), phase_spec=None, ), symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), execution_cases=execution_cases, )
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), ))
class TestSetValidationOfValue(TestCaseBase): def runTest(self): # ACT & ASSERT # name = StringLiteralAbsStx('name') def expectation_corresponding_to( case: str_src_validation_cases.ValidationCase): return (self.conf.expect_failing_validation_pre_sds( case.assertion.pre_sds, symbol_usages=case.symbol_context.usages_assertion) if not case.expectation.passes_pre_sds else self.conf.expect_hard_error_of_main__any( symbol_usages=case.symbol_context.usages_assertion)) for phase_spec in PHASE_SPECS: for validation_case in str_src_validation_cases.failing_validation_cases( ): with self.subTest(phase_spec=phase_spec, validation=validation_case.name): self.conf.instruction_checker.check_parsing__abs_stx__const( self, self.conf.parser(), SetVariableArgumentsAbsStx( name, validation_case.value.syntax, phase_spec=phase_spec), self.conf.arrangement(symbols=validation_case.value. symbol_context.symbol_table), expectation_corresponding_to(validation_case.value), )
def runTest(self): vars_before = [ ValueWSymRefsAndVarRefs.REFERENCED_VAR_1, ValueWSymRefsAndVarRefs.REFERENCED_VAR_2 ] var_to_set__resolved = NameAndValue( NameWSymRefs.RESOLVED_STR, ValueWSymRefsAndVarRefs.VALUE_WO_VAR_REFS) all_symbols = NameWSymRefs.SYMBOL_CONTEXTS + ValueWSymRefsAndVarRefs.SYMBOL_CONTEXTS execution_cases = _exe_cases_of_modification( before_modification=vars_before, after_modification=vars_before + [var_to_set__resolved], symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ) # ACT & ASSERT # for phase_spec__source in [None, Phase.NON_ACT]: CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx( NameWSymRefs.STRING_ABS_STX, StringSourceOfStringAbsStx( ValueWSymRefsAndVarRefs.STRING_ABS_STX), phase_spec=phase_spec__source, ), symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), execution_cases=execution_cases, sub_test_identifiers={ 'phase_spec__source': phase_spec__source, }, )
def test_target_is_all_phases(self): # ACT & ASSERT # setup = self.ENVIRONS_SETUP__DIFFERENT identical_setup = self.ENVIRONS_SETUP__IDENTICAL var_to_set = self.VAR_TO_SET arbitrary_phase = Phase.NON_ACT all_execution_cases = [ NArrEx( 'non-act/populated, act/populated', arr( non_act=setup.as_dict(Phase.NON_ACT), the_act=setup.as_dict(Phase.ACT), defaults_getter=get_empty_environ, ), setup.expectation_of_addition_to_phase_all(var_to_set), ), NArrEx( 'non-act/populated, act/not populated', arr( non_act=setup.as_dict(Phase.NON_ACT), the_act=None, defaults_getter=setup.defaults_getter_with_values( Phase.ACT), ), setup.expectation_of_addition_to_phase_all(var_to_set), ), NArrEx( 'non-act/not populated, act/populated', arr( non_act=None, the_act=setup.as_dict(Phase.ACT), defaults_getter=setup.defaults_getter_with_values( Phase.NON_ACT), ), setup.expectation_of_addition_to_phase_all(var_to_set), ), NArrEx( 'non-act/not populated, act/not populated', arr( non_act=None, the_act=None, defaults_getter=identical_setup. defaults_getter_with_values(arbitrary_phase), ), identical_setup.expectation_of_addition_to_phase_all( var_to_set), ), ] # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx.of_nav(var_to_set, phase_spec=None), symbol_usages=asrt.is_empty_sequence, execution_cases=all_execution_cases, )
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 runTest(self): # ARRANGE # for phase_spec in PHASE_SPECS: cases = [ NameAndValue( 'missing arguments', SetVariableArgumentsAbsStx( StringLiteralAbsStx(''), StringSourceOfStringAbsStx.of_str(''), phase_spec=phase_spec, ), ), NameAndValue( 'more than three arguments', SetVariableArgumentsAbsStx( StringLiteralAbsStx('arg1'), StringSourceOfStringAbsStx.of_str('arg2 arg3'), phase_spec=phase_spec, ), ), NameAndValue( 'invalid quoting of value', SetVariableArgumentsAbsStx( StringLiteralAbsStx('name'), StringSourceOfStringAbsStx(MISSING_END_QUOTE__SOFT), phase_spec=phase_spec, ), ), ] for case in cases: # ACT & ASSERT # PARSE_CHECKER.check_invalid_syntax__abs_stx( self, case.value, { 'phase_spec': phase_spec, 'variant': case.name, }, )
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 _check_modification_of_single_phase( self, phase_to_modify: Phase, var_to_set: EnvVar, execution_cases: ExeCasesForContentsOfOtherGetter, contents_of_non_checked_phase__populated: EnvVarDict): # ARRANGE # all_execution_cases = ( execution_cases(contents_of_non_checked_phase__populated) + execution_cases(None)) # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx.of_nav(var_to_set, phase_spec=phase_to_modify), symbol_usages=asrt.is_empty_sequence, execution_cases=all_execution_cases, )
def runTest(self): # ARRANGE # var_val = NameAndValue('name', 'value') instruction_argument = SetVariableArgumentsAbsStx.of_nav( var_val, phase_spec=Phase.ACT) expected_environ = {} empty_environ = {} def mk_arrangement(): return self.conf.arrangement(environ=dict(empty_environ)) # ACT & ASSERT # self.conf.instruction_checker.check_parsing__abs_stx( self, self.conf.parser(), instruction_argument, mk_arrangement, self.conf.expect_success(instruction_settings=asrt_is.matches( environ=asrt.equals(expected_environ))))
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_target_is_act(self): # ACT & ASSERT # phase_spec__source = Phase.ACT phase_spec__to_check_for_modifications = Phase.NON_ACT environs_setup = EnvironsSetupForSet( the_act=[NameAndValue('act_1', ' value of act_1')], non_act=[NameAndValue('non_act_1', ' value of non_act_1')], ) var_to_set = NameAndValue('var_to_set', 'value_to_set') # ACT & ASSERT # CHECKER.check__abs_stx__multi__std_layouts_and_source_variants( self, SetVariableArgumentsAbsStx.of_nav(var_to_set, phase_spec=phase_spec__source), symbol_usages=asrt.is_empty_sequence, execution_cases=_exe_cases_for_unmodified( environs_setup, phase_spec__to_check_for_modifications), )
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_value_with_hard_quoted_value_SHOULD_skip_symbol_substitution( self): # ARRANGE # variable_name = 'variable_to_assign' my_symbol = NameAndValue('my_symbol', 'my symbol value') your_symbol = NameAndValue('your_symbol', 'your symbol value') value_template = 'pre {MY_SYMBOL} {YOUR_SYMBOL} post' 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), ) expected_environ_after_main = { variable_name: value_source_string, } source_syntax = SetVariableArgumentsAbsStx.of_str( variable_name, value_source_string, phase_spec=None, quoting=QuoteType.HARD) # ACT & ASSERT # CHECKER.check__abs_stx__std_layouts_and_source_variants( self, source_syntax, Arrangement.setup_phase_aware( 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([]), ), )
def runTest(self): # ARRANGE # var_val = NameAndValue('name', 'value') instruction_argument = SetVariableArgumentsAbsStx.of_nav( var_val, phase_spec=Phase.ACT) expected_environ = {var_val.name: var_val.value} env_before_modification = {} # ACT & ASSERT # CHECKER.check_multi_source__abs_stx( self, instruction_argument, arr( env_before_modification, env_before_modification, ), expect( instruction_settings=env_before_modification, setup_settings=expected_environ, ), )
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 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 runTest(self): # ARRANGE # var_in_default = NameAndValue('var_in_default', 'value of var in default') var_to_set = NameAndValue('var_to_set', 'value') expected_environ = NameAndValue.as_dict([var_in_default, var_to_set]) def get_default_environ() -> Dict[str, str]: return NameAndValue.as_dict([var_in_default]) instruction_argument = SetVariableArgumentsAbsStx.of_nav( var_to_set, phase_spec=None) def mk_arrangement(): return self.conf.arrangement( environ=None, default_environ_getter=get_default_environ, ) # ACT & ASSERT # self.conf.instruction_checker.check_parsing__abs_stx( self, self.conf.parser(), instruction_argument, mk_arrangement, self.conf.expect_success(instruction_settings=asrt_is.matches( environ=asrt.equals(expected_environ))))
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, })
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, }, )