def runTest(self): # ARRANGE # string_72_plus = StringSymbolContext.of_constant( 'SYMBOL_72_PLUS', '72+', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) string_5 = StringSymbolContext.of_constant( 'SYMBOL_5', '5', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) expected = 72 + 5 all_symbols = [string_72_plus, string_5] value_syntax = StringConcatAbsStx([ string_72_plus.abstract_syntax, string_5.abstract_syntax, ]) # ACT & ASSERT # self.conf.instruction_checker.check_parsing__abs_stx__const( self, self.conf.parser(), InstructionArgumentsAbsStx.of_int(value_syntax), self.conf.arrangement( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ), self.conf.expect_success( symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), instruction_settings=asrt_is.matches( timeout=asrt.equals(expected))))
def runTest(self): # ARRANGE # var_to_unset = NameAndValue('var_to_unset', 'value of var to unset') other_var = NameAndValue('other_var', 'val of other var') instruction_argument = UnsetVariableArgumentsAbsStx.of_str( var_to_unset.name, phase_spec=None) vars_from_defaults_getter = [var_to_unset, other_var] environ_wo_var_to_unset = NameAndValue.as_dict([other_var]) def get_default_environ() -> Dict[str, str]: return NameAndValue.as_dict(vars_from_defaults_getter) 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(environ_wo_var_to_unset))))
def runTest(self): string_72_plus = StringSymbolContext.of_constant( 'SYMBOL_72_PLUS', '72+', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) string_5 = StringSymbolContext.of_constant( 'SYMBOL_5', '5', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) expected = 72 + 5 all_symbols = [string_72_plus, string_5] value_syntax = StringConcatAbsStx([ string_72_plus.abstract_syntax, string_5.abstract_syntax, ]) CHECKER.check__abs_stx__layout_and_source_variants( self, InstructionArgumentsAbsStx.of_int(value_syntax), Arrangement.phase_agnostic( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ), MultiSourceExpectation.phase_agnostic( symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), instruction_settings=asrt_instr_settings.matches( timeout=asrt.equals(expected))), )
def expectation_of_removal_from_phase( self, phase: Phase, var_to_remove: str) -> ExecutionExpectation: return ExecutionExpectation.setup_phase_aware( main_result=asrt.is_none, instruction_settings=asrt_instr_settings.matches( environ=asrt.equals( self.with_removed__as_dict(phase, var_to_remove))))
def expectation_of_addition_to_phase( self, phase: Phase, var_to_add: EnvVar) -> ExecutionExpectation: return ExecutionExpectation.setup_phase_aware( main_result=asrt.is_none, instruction_settings=asrt_instr_settings.matches( environ=asrt.equals(self.with_added__as_dict( phase, var_to_add))))
def expectation( non_act: Optional[Mapping[str, str]], the_act: Optional[Mapping[str, str]]) -> ExecutionExpectation[None]: return ExecutionExpectation.setup_phase_aware( main_result=asrt.is_none, instruction_settings=asrt_instr_settings.matches( environ=asrt.equals(non_act), ), setup_settings=asrt_setup_settings.matches( environ=asrt.equals(the_act)))
def runTest(self): CHECKER.check__abs_stx__layout_and_source_variants( self, InstructionArgumentsAbsStx.of_none(), Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( instruction_settings=asrt_instr_settings.matches( timeout=asrt.is_none)), )
def expect( instruction_settings: Optional[Mapping[str, str]], setup_settings: Optional[Mapping[str, str]], ) -> MultiSourceExpectation: return MultiSourceExpectation( instruction_settings=asrt_instr_settings.matches( environ=asrt.equals(instruction_settings), ), settings_builder=asrt_setup_settings.matches( environ=asrt.equals(setup_settings), stdin=asrt.is_none, ))
def runTest(self): # ARRANGE # var_name = 'var_to_unset' instruction_argument = UnsetVariableArgumentsAbsStx.of_str( var_name, phase_spec=None) environ_wo_var_to_unset = {'other_var': 'val of other var'} def mk_arrangement(): return self.conf.arrangement(environ=dict(environ_wo_var_to_unset)) # 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(environ_wo_var_to_unset))))
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 runTest(self): # ARRANGE # var_name = 'var_to_unset' other_var = NameAndValue('other_var', 'val of other var') instruction_argument = UnsetVariableArgumentsAbsStx.of_str( var_name, phase_spec=Phase.ACT) environ_w_var_to_unset = { var_name: 'value of var to unset', other_var.name: other_var.value } def mk_arrangement(): return self.conf.arrangement(environ=dict(environ_w_var_to_unset)) # 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(environ_w_var_to_unset))))
def runTest(self): cases = [ NIE( 'constant 5', 5, StringLiteralAbsStx('5'), ), NIE( 'constant 5 / quoted', 5, StringLiteralAbsStx('5', QuoteType.SOFT), ), NIE( 'constant 75', 75, StringLiteralAbsStx('75'), ), NIE( 'python expr', 5, StringLiteralAbsStx('2+3'), ), NIE( 'python expr with space', 7, StringLiteralAbsStx('2*3 + 1', QuoteType.HARD), ), NIE( 'python expr len', 11, StringLiteralAbsStx('len("hello world")', QuoteType.HARD), ), ] for case in cases: with self.subTest(case.name): CHECKER.check__abs_stx__layout_and_source_variants( self, InstructionArgumentsAbsStx.of_int(case.input_value), Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( instruction_settings=asrt_instr_settings.matches( timeout=asrt.equals(case.expected_value))), )
def test_populate_environ(self): default_from_default_getter = {'default': 'value of default'} default_environs = {'in_environs': 'value of var in environs'} def default_environ_getter() -> Dict[str, str]: return default_from_default_getter self._check( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, utils.single_line_source(), sut.Arrangement( default_environ_getter=default_environ_getter, process_execution_settings=ProcessExecutionSettings. from_non_immutable(environ=default_environs), ), sut.Expectation(instruction_settings=asrt_instr_settings.matches( environ=asrt.equals(default_environs), return_value_from_default_getter=asrt.equals( default_from_default_getter)), proc_exe_settings=asrt_pes.matches( environ=asrt.equals(default_environs))), )
def test_populate_environ(self): default_from_default_getter = {'default': 'value of default'} default_environs = {'in_environs': 'value of var in environs'} def default_environ_getter() -> Dict[str, str]: return dict(default_from_default_getter) self._check_source_and_exe_variants( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, Arrangement.phase_agnostic( default_environ_getter=default_environ_getter, process_execution_settings=ProcessExecutionSettings.from_non_immutable(environ=default_environs), ), MultiSourceExpectation.phase_agnostic( instruction_settings=asrt_instr_settings.matches( environ=asrt.equals(default_environs), return_value_from_default_getter=asrt.equals(default_from_default_getter) ), proc_exe_settings=asrt_pes.matches( environ=asrt.equals(default_environs) ) ), )
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))))