def test_setup(self): # ARRANGE # cases = { STEP__VALIDATE_POST_SETUP: { EXECUTION__VALIDATION_ERROR: setup_phase_instruction_that( validate_post_setup=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: setup_phase_instruction_that( validate_post_setup=SVH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: setup_phase_instruction_that( validate_post_setup_initial_action=DO_RAISES_EXCEPTION), }, STEP__MAIN: { EXECUTION__HARD_ERROR: setup_phase_instruction_that(main=SH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: setup_phase_instruction_that( main_initial_action=DO_RAISES_EXCEPTION), }, } # ACT & ASSERT # self._check_and_assert_sds_is_preserved_and_is_printed( phase_identifier.SETUP, cases)
def test_setup(self): # ARRANGE # cases = { STEP__VALIDATE_POST_SETUP: { EXECUTION__VALIDATION_ERROR: setup_phase_instruction_that(validate_post_setup=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: setup_phase_instruction_that(validate_post_setup=SVH_HARD_ERROR), EXECUTION__IMPLEMENTATION_ERROR: setup_phase_instruction_that(validate_post_setup_initial_action=DO_RAISES_EXCEPTION), }, STEP__MAIN: { EXECUTION__HARD_ERROR: setup_phase_instruction_that(main=SH_HARD_ERROR), EXECUTION__IMPLEMENTATION_ERROR: setup_phase_instruction_that(main_initial_action=DO_RAISES_EXCEPTION), }, } # ACT & ASSERT # self._check_and_assert_sds_is_preserved_and_is_printed(phase_identifier.SETUP, cases)
def test_setup(self): # ARRANGE # cases = { EXECUTION__VALIDATION_ERROR: setup_phase_instruction_that(validate_pre_sds=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: setup_phase_instruction_that(validate_pre_sds=SVH_HARD_ERROR), EXECUTION__IMPLEMENTATION_ERROR: setup_phase_instruction_that(validate_pre_sds_initial_action=DO_RAISES_EXCEPTION), } # ACT & ASSERT # self._check_and_assert_sds_is_not_created_and_stdout_is_empty(phase_identifier.SETUP, cases)
def test_setup(self): # ARRANGE # cases = { EXECUTION__VALIDATION_ERROR: setup_phase_instruction_that( validate_pre_sds=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: setup_phase_instruction_that(validate_pre_sds=SVH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: setup_phase_instruction_that( validate_pre_sds_initial_action=DO_RAISES_EXCEPTION), } # ACT & ASSERT # self._check_and_assert_sds_is_not_created_and_stdout_is_empty( phase_identifier.SETUP, cases)
def runTest(self): conf = self.configuration defined_symbol = data_symbol_utils.string_symbol_definition('symbol_name') error_message_for_failed_restriction = 'error message' reference_with_restriction_failure = SymbolReference( defined_symbol.name, ReferenceRestrictionsOnDirectAndIndirect( direct=value_restriction_that_is_unconditionally_unsatisfied(error_message_for_failed_restriction))) test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \ .add(PartialPhase.SETUP, setup_phase_instruction_that(symbol_usages=do_return([defined_symbol]))) \ .add(conf.phase, conf.instruction_that_returns([reference_with_restriction_failure])) execute_test_case_with_recording( self, Arrangement(test_case), Expectation( asrt_result.matches2( PartialExeResultStatus.VALIDATION_ERROR, asrt_result.has_no_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_phase_and_message_assertion( conf.step, asrt.equals(error_message_for_failed_restriction)), ), conf.expected_steps_before_failing_instruction, ) )
def _test_case(self) -> test_case_doc.TestCase: return full_test_case_with_instructions( [configuration_phase_instruction_that( main_initial_action=_RecordCurrDir(self.recorder, phase_step.CONFIGURATION__MAIN).call)], [setup_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.SETUP__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.SETUP__MAIN))], [act_phase_instruction_with_source(LineSequence(1, ('not used',)))], [before_assert_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.BEFORE_ASSERT__MAIN))], [assert_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.ASSERT__MAIN))], [cleanup_phase_instruction_that( main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.CLEANUP__MAIN))], )
def test_hard_error_in_setup_main_step(self): py_pgm_setup = PyProgramSetup('some output to stdout', 'some output to stderr', 72) test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr( act_phase_source=py_pgm_setup.as_line_sequence()) \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_return(sh.new_sh_hard_error('hard error msg from setup')))) self._check( arr_for_py3_source(test_case), Expectation( asrt_result.matches2( PartialExeResultStatus.HARD_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_message( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, 'hard error msg from setup'), ), atc_stdout_output=asrt.equals(''), atc_stderr_output=asrt.equals(''), step_recordings= [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def test_hard_error_in_setup_main_step(self): test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_return(sh.new_sh_hard_error('hard error msg from setup')))) self._check( Arrangement(test_case), Expectation( asrt_result.matches2( PartialExeResultStatus.HARD_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_message( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, 'hard error msg from setup'), ), [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def test_hard_error_in_setup_main_step(self): py_pgm_setup = PyProgramSetup('some output to stdout', 'some output to stderr', 72) test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr( act_phase_source=py_pgm_setup.as_line_sequence()) \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_return(sh.new_sh_hard_error__str('hard error msg from setup')))) self._check( arr_for_py3_source(test_case), Expectation( asrt_result.matches2( ExecutionFailureStatus.HARD_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_message( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, 'hard error msg from setup'), ), atc_stdout_output=asrt.equals(''), atc_stderr_output=asrt.equals(''), step_recordings=[phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [ phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def test_implementation_error_in_setup_main_step(self): test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_raise(test.ImplementationErrorTestException()))) self._check( Arrangement(test_case, act_executor_execute=execute_action_that_returns_exit_code(5)), Expectation( asrt_result.matches2( PartialExeResultStatus.IMPLEMENTATION_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_exception( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, test.ImplementationErrorTestException), ), [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def test_that_symbols_from_arrangement_exist_in_environment(self): symbol_name = 'symbol_name_in_setup_phase' symbol_value = 'the symbol value in setup phase' symbol_table_of_arrangement = data_symbol_utils.symbol_table_with_single_string_value(symbol_name, symbol_value) expected_symbol_table = data_symbol_utils.symbol_table_with_single_string_value(symbol_name, symbol_value) assertion_for_validation = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_path_resolving_environment_that_is_first_arg) assertion_for_main = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_instruction_environment_that_is_first_arg) self._check( utils.ParserThatGives( setup_phase_instruction_that( validate_pre_sds_initial_action=assertion_for_validation, validate_post_setup_initial_action=assertion_for_validation, main_initial_action=assertion_for_main, )), utils.single_line_source(), sut.Arrangement(symbols=symbol_table_of_arrangement), sut.Expectation(), )
def test_internal_error(self): test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_raise(test.ImplementationErrorTestException()))) self._check( Arrangement(test_case, atc_execute=execute_action_that_returns_exit_code(5)), Expectation( asrt_result.matches2( ExecutionFailureStatus.INTERNAL_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_exception( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, test.ImplementationErrorTestException), ), [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [ phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def _test_case(self) -> test_case_doc.TestCase: return full_test_case_with_instructions( [configuration_phase_instruction_that( main_initial_action=_RecordCurrDir(self.recorder, phase_step.CONFIGURATION__MAIN))], [setup_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.SETUP__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.SETUP__MAIN))], [act_phase_instruction_with_source(LineSequence(1, ('not used',)))], [before_assert_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.BEFORE_ASSERT__MAIN))], [assert_phase_instruction_that( validate_post_setup_initial_action=_RecordCurrDir(self.recorder, phase_step.ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.ASSERT__MAIN))], [cleanup_phase_instruction_that( main_initial_action=_RecordCurrDirThenMakeDirAndChangeToIt(self.recorder, phase_step.CLEANUP__MAIN))], )
def _check_defaults(self, default_environ: Optional[Mapping[str, str]]): recording_media = _empty_recording_media() expected_recordings = [ # setup # RecordingEntry.from_settings(PhaseEnum.SETUP, None, default_environ), # act # RecordingEntry.from_settings(PhaseEnum.ACT, None, default_environ), ] helper = RecordingsHelper(recording_media) test_case = partial_test_case_with_instructions([ setup_phase_instruction_that( main_initial_action=helper.action_for_recordings_for( PhaseEnum.SETUP, None), ), ], ) actor_that_records_env_vars_of_act_exe_input = ActorThatRunsConstantActions( execute_initial_action=helper. actor_action_for_recording_environ_of_act_exe_input, ) # ACT # test__va( self, test_case, Arrangement( actor=actor_that_records_env_vars_of_act_exe_input, environ=default_environ, ), result_is_pass(), ) self.assertEqual(expected_recordings, recording_media, 'recordings')
def test_instruction_environment_specifies_correct_tmp_dir_space_for_each_instruction( self): # ARRANGE # recorder = {} setup_phase_instr_that_records = setup_phase_instruction_that( validate_post_setup_initial_action= RecordTmpDirForInstructionInPhase(PhaseEnum.SETUP, recorder), main_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.SETUP, recorder).call, ) before_assert_phase_instr_that_records = before_assert_phase_instruction_that( validate_post_setup_initial_action= RecordTmpDirForInstructionInPhase(PhaseEnum.BEFORE_ASSERT, recorder), main_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.BEFORE_ASSERT, recorder).call) assert_phase_instr_that_records = assert_phase_instruction_that( validate_post_setup_initial_action= RecordTmpDirForInstructionInPhase(PhaseEnum.ASSERT, recorder), main_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.ASSERT, recorder).call) cleanup_phase_instr_that_records = cleanup_phase_instruction_that( main_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.CLEANUP, recorder).call) test_case = partial_test_case_with_instructions( [ setup_phase_instr_that_records, setup_phase_instr_that_records, ], [act_phase_instruction_with_source(LineSequence(1, ('line', )))], [ before_assert_phase_instr_that_records, before_assert_phase_instr_that_records, ], [ assert_phase_instr_that_records, assert_phase_instr_that_records, ], [ cleanup_phase_instr_that_records, cleanup_phase_instr_that_records, ], ) actor_that_registers_tmp_dirs = ActorThatRunsConstantActions( validate_post_setup_initial_action= RecordTmpDirForInstructionInPhase(PhaseEnum.ACT, recorder), prepare_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.ACT, recorder), execute_initial_action=RecordTmpDirForInstructionInPhase( PhaseEnum.ACT, recorder), ) # ACT & ASSERT # test(self, test_case, actor_that_registers_tmp_dirs, functools.partial(tmp_dir_is_correct_for_each_instruction, recorder, 2), is_keep_sandbox=False)
def setup_phase_instruction_that_records_property_of_env_for_each_step( property_recorder: PropertyRecorderBuilder) -> SetupPhaseInstruction: return setup_phase_instruction_that( validate_pre_sds_initial_action=property_recorder.of_first_arg( step.SETUP__VALIDATE_PRE_SDS), validate_post_setup_initial_action=property_recorder.of_first_arg( step.SETUP__VALIDATE_POST_SETUP), main_initial_action=property_recorder.of_first_arg(step.SETUP__MAIN))
def setup_phase_instruction_that_records_a_value_per_step( recorder_for) -> SetupPhaseInstruction: return setup_phase_instruction_that( validate_pre_sds_initial_action=recorder_for( step.SETUP__VALIDATE_PRE_SDS), main_initial_action=recorder_for(step.SETUP__MAIN), validate_post_setup_initial_action=recorder_for( step.SETUP__VALIDATE_POST_SETUP), )
def runTest(self): default_environ = None modified_environ = {'modified_var': 'val of modified var'} recording_media = _empty_recording_media() expected_recordings = [ # setup # RecordingEntry.from_settings(PhaseEnum.SETUP, PosInPhase.BEFORE_MODIFY, default_environ), RecordingEntry.from_settings(PhaseEnum.SETUP, PosInPhase.AFTER_MODIFY, modified_environ), # act # RecordingEntry.from_settings(PhaseEnum.ACT, None, modified_environ), ] helper = RecordingsHelper(recording_media) test_case = partial_test_case_with_instructions([ setup_phase_instruction_that( main_initial_action=helper.action_for_recordings_for( PhaseEnum.SETUP, PosInPhase.BEFORE_MODIFY), ), setup_phase_instruction_that( main_initial_action=ActionThatSetsSettings( dict(modified_environ)).initial_action, ), setup_phase_instruction_that( main_initial_action=helper.action_for_recordings_for( PhaseEnum.SETUP, PosInPhase.AFTER_MODIFY), ), ], ) actor_that_records_env_vars_of_act_exe_input = ActorThatRunsConstantActions( execute_initial_action=helper. actor_action_for_recording_environ_of_act_exe_input, ) # ACT # test__va( self, test_case, Arrangement( actor=actor_that_records_env_vars_of_act_exe_input, environ=default_environ, ), result_is_pass(), ) self.assertEqual(expected_recordings, recording_media, 'recordings')
def _test_case(self) -> test_case_doc.TestCase: return full_test_case_with_instructions( [ configuration_phase_instruction_that( main_initial_action= _ConfigurationPhaseActionThatSetsHdsCaseDirToParent()), configuration_phase_instruction_that( main_initial_action= _ConfigurationPhaseActionThatSetsHdsActDirToParentParent()) ], [ setup_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars( self.recorder, phase_step.SETUP__VALIDATE_PRE_SDS).call, validate_post_setup_initial_action=_RecordEnvVars( self.recorder, phase_step.SETUP__VALIDATE_POST_SETUP).call, main_initial_action=_RecordEnvVars( self.recorder, phase_step.SETUP__MAIN).setup_main) ], [], [ before_assert_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars( self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_PRE_SDS).call, validate_post_setup_initial_action=_RecordEnvVars( self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP).call, main_initial_action=_RecordEnvVars( self.recorder, phase_step.BEFORE_ASSERT__MAIN).non_setup_main) ], [ assert_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars( self.recorder, phase_step.ASSERT__VALIDATE_PRE_SDS).call, validate_post_setup_initial_action=_RecordEnvVars( self.recorder, phase_step.ASSERT__VALIDATE_POST_SETUP).call, main_initial_action=_RecordEnvVars( self.recorder, phase_step.ASSERT__MAIN).non_setup_main) ], [ cleanup_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars( self.recorder, phase_step.CLEANUP__VALIDATE_PRE_SDS).call, main_initial_action=_RecordEnvVars( self.recorder, phase_step.CLEANUP__MAIN).non_setup_main) ], )
def test_that_default_expectation_assumes_no_symbol_usages(self): with self.assertRaises(utils.TestError): unexpected_symbol_usages = [data_symbol_utils.symbol_reference('symbol_name')] self._check( utils.ParserThatGives( setup_phase_instruction_that( symbol_usages=do_return(unexpected_symbol_usages))), single_line_source(), sut.Arrangement(), sut.Expectation(), )
def test_failure(self): with self.assertRaises(utils.TestError): self._check( utils.ParserThatGives(setup_phase_instruction_that()), single_line_source(), sut.Arrangement( settings_builder=SetupSettingsBuilder.new_empty()), sut.Expectation(settings_builder=asrt.sub_component( 'stdin', lambda model: model.actual.stdin, asrt.is_not_none)), )
def new_setup_instruction(self, value_for_symbol_usages, value_for_validate_pre_sds, value_for_main, value_for_validate_post_sds, ) -> SetupPhaseInstruction: return setup_phase_instruction_that( symbol_usages_initial_action=self._do_record_first_invokation(value_for_symbol_usages), validate_pre_sds=self._do_record_and_return_svh(value_for_validate_pre_sds), validate_post_setup=self._do_record_and_return_svh( value_for_validate_post_sds), main=self._do_record_and_return_sh(value_for_main))
def test_that_fails_due_to_missing_symbol_reference(self): with self.assertRaises(utils.TestError): symbol_usages_of_instruction = [] symbol_usages_of_expectation = [data_symbol_utils.symbol_reference('symbol_name')] self._check( utils.ParserThatGives( setup_phase_instruction_that( symbol_usages=do_return(symbol_usages_of_instruction))), single_line_source(), sut.Arrangement(), sut.Expectation( symbol_usages=sym_asrt.equals_symbol_references(symbol_usages_of_expectation)), )
def test_that_default_expectation_assumes_no_symbol_usages(self): with self.assertRaises(utils.TestError): unexpected_symbol_usages = [ data_references.reference_to__on_direct_and_indirect( 'symbol_name') ] self._check( utils.ParserThatGives( setup_phase_instruction_that( symbol_usages=do_return(unexpected_symbol_usages))), single_line_source(), sut.Arrangement(), sut.Expectation(), )
def new_setup_instruction( self, value_for_symbol_usages, value_for_validate_pre_sds, value_for_main, value_for_validate_post_sds, ) -> SetupPhaseInstruction: return setup_phase_instruction_that( symbol_usages_initial_action=self._do_record_first_invokation( value_for_symbol_usages), validate_pre_sds=self._do_record_and_return_svh( value_for_validate_pre_sds), validate_post_setup=self._do_record_and_return_svh( value_for_validate_post_sds), main=self._do_record_and_return_sh(value_for_main))
def test_that_fails_due_to_missing_symbol_reference(self): with self.assertRaises(utils.TestError): symbol_usages_of_instruction = [] self._check( utils.ParserThatGives( setup_phase_instruction_that(symbol_usages=do_return( symbol_usages_of_instruction))), single_line_source(), sut.Arrangement(), sut.Expectation(symbol_usages=asrt.matches_singleton_sequence( matches_data_type_symbol_reference( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering())) ), )
def test_instruction_environment_specifies_correct_log_dir_for_each_phase(self): recorder = {} test_case = partial_test_case_with_instructions( [setup_phase_instruction_that(main_initial_action=RecordLogDirForPhase(PhaseEnum.SETUP, recorder))], [act_phase_instruction_with_source(LineSequence(1, ('line',)))], [before_assert_phase_instruction_that(main_initial_action=RecordLogDirForPhase(PhaseEnum.BEFORE_ASSERT, recorder))], [assert_phase_instruction_that(main_initial_action=RecordLogDirForPhase(PhaseEnum.ASSERT, recorder))], [cleanup_phase_instruction_that(main_initial_action=RecordLogDirForPhase(PhaseEnum.CLEANUP, recorder))], ) test( self, test_case, dummy_actor(), functools.partial(log_dir_is_correct_for_each_phase, recorder), is_keep_sandbox=False)
def instruction_set() -> InstructionsSetup: return InstructionsSetup( config_instruction_set=dict( [instruction_item('conf_instruction', instr.configuration_phase_instruction_that())]), setup_instruction_set=dict( [instruction_item('setup_instruction', instr.setup_phase_instruction_that())]), before_assert_instruction_set=dict( [instruction_item('before_assert_instruction', instr.before_assert_phase_instruction_that())]), assert_instruction_set=dict( [instruction_item('assert_instruction', instr.assert_phase_instruction_that())]), cleanup_instruction_set=dict( [instruction_item('cleanup_instruction', instr.cleanup_phase_instruction_that())]), )
def test_hard_error_exception(self): test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr() \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_raise(hard_error_ex('hard error exception msg from setup')))) self._check( Arrangement(test_case), Expectation( asrt_result.matches2( ExecutionFailureStatus.HARD_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_message( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, 'hard error exception msg from setup'), ), [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [ phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def test_set_environment_variable_in_phase_setup(self): recorder = _RecorderOfExistenceOfGlobalEnvVar(_unique_variable_name()) test_case = partial_test_case_with_instructions( [setup_phase_instruction_that( main_initial_action=Sequence([SetEnvironmentVariableViaInstructionArguments(recorder.variable_name), recorder.for_step(step.SETUP__MAIN)]), validate_post_setup_initial_action=recorder.for_step(step.SETUP__VALIDATE_POST_SETUP))], _act_phase_instructions_that_are_not_relevant_to_this_test(), [before_assert_phase_instruction_that( validate_post_setup_initial_action=recorder.for_step(step.BEFORE_ASSERT__VALIDATE_POST_SETUP), main_initial_action=recorder.for_step(step.BEFORE_ASSERT__MAIN))], [assert_phase_instruction_that( validate_post_setup_initial_action=recorder.for_step(step.ASSERT__VALIDATE_POST_SETUP), main_initial_action=recorder.for_step(step.ASSERT__MAIN))], [cleanup_phase_instruction_that( main_initial_action=recorder.for_step(step.CLEANUP__MAIN))], ) test__va( self, test_case, Arrangement( actor=_actor_that_records_existence_of_var_in_global_env(recorder)), AssertPhasesWhereTheEnvironmentVariableExistsInTheGlobalEnvironmentIsEmpty(recorder.recorded_steps))
def test_that_symbols_from_arrangement_exist_in_environment(self): symbol = StringConstantSymbolContext( 'symbol_name_in_setup_phase', 'the symbol value in setup phase') symbol_table_of_arrangement = symbol.symbol_table expected_symbol_table = symbol.symbol_table assertion_for_validation = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_path_resolving_environment_that_is_first_arg) assertion_for_main = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_instruction_environment_that_is_first_arg) self._check( utils.ParserThatGives( setup_phase_instruction_that( validate_pre_sds_initial_action=assertion_for_validation, validate_post_setup_initial_action=assertion_for_validation, main_initial_action=assertion_for_main, )), utils.single_line_source(), sut.Arrangement(symbols=symbol_table_of_arrangement), sut.Expectation(), )
def _test_case(self) -> test_case_doc.TestCase: return full_test_case_with_instructions( [ configuration_phase_instruction_that( main_initial_action=_ConfigurationPhaseActionThatSetsHomeCaseDirToParent()), configuration_phase_instruction_that( main_initial_action=_ConfigurationPhaseActionThatSetsHomeActDirToParentParent()) ], [setup_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars(self.recorder, phase_step.SETUP__VALIDATE_PRE_SDS), validate_post_setup_initial_action=_RecordEnvVars(self.recorder, phase_step.SETUP__VALIDATE_POST_SETUP), main_initial_action=_RecordEnvVars(self.recorder, phase_step.SETUP__MAIN))], [], [before_assert_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars(self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_PRE_SDS), validate_post_setup_initial_action=_RecordEnvVars(self.recorder, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordEnvVars(self.recorder, phase_step.BEFORE_ASSERT__MAIN))], [assert_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars(self.recorder, phase_step.ASSERT__VALIDATE_PRE_SDS), validate_post_setup_initial_action=_RecordEnvVars(self.recorder, phase_step.ASSERT__VALIDATE_POST_SETUP), main_initial_action=_RecordEnvVars(self.recorder, phase_step.ASSERT__MAIN))], [cleanup_phase_instruction_that( validate_pre_sds_initial_action=_RecordEnvVars(self.recorder, phase_step.CLEANUP__VALIDATE_PRE_SDS), main_initial_action=_RecordEnvVars(self.recorder, phase_step.CLEANUP__MAIN))], )
def test_one_symbol_is_predefined_and_one_symbol_is_defined_in_the_setup_phase(self): predefined_symbol = NameAndValue('predefined symbol', 'predefined string constant symbol value') defined_symbol = NameAndValue('defined symbol', 'value of symbol defined in the setup phase (not used in this test)') predefined_symbols_table = SymbolTable({ predefined_symbol.name: symbol_utils.container(string_resolvers.str_constant(predefined_symbol.value)) }) predefined_symbols = frozenset((predefined_symbol.name,)) predefined_and_defined_symbols = frozenset((predefined_symbol.name, defined_symbol.name)) symbol_definition = data_symbol_utils.string_symbol_definition(defined_symbol.name, defined_symbol.value) symbol_usages_of_instruction_that_defines_symbol = [symbol_definition] expected_phase_2_step_2_names_set = { PhaseEnum.SETUP: { step.SETUP__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.SETUP__MAIN.step: predefined_symbols, step.SETUP__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, }, PhaseEnum.ACT: { step.ACT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.ACT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.ACT__PREPARE.step: predefined_and_defined_symbols, step.ACT__EXECUTE.step: predefined_and_defined_symbols, }, PhaseEnum.BEFORE_ASSERT: { step.BEFORE_ASSERT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.BEFORE_ASSERT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.BEFORE_ASSERT__MAIN.step: predefined_and_defined_symbols, }, PhaseEnum.ASSERT: { step.ASSERT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.ASSERT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.ASSERT__MAIN.step: predefined_and_defined_symbols, }, PhaseEnum.CLEANUP: { step.CLEANUP__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.CLEANUP__MAIN.step: predefined_and_defined_symbols, }, } actual_phase_2_step_2_names_set = psr.new_phase_enum_2_empty_dict() def recorder_for(phase_step: SimplePhaseStep): return psr.StepRecordingAction(phase_step, actual_phase_2_step_2_names_set, get_symbols_name_set_from_instruction_environment) test_case = partial_test_case_with_instructions( [ setup_phase_instruction_that( symbol_usages=do_return(symbol_usages_of_instruction_that_defines_symbol), validate_pre_sds_initial_action=recorder_for(step.SETUP__VALIDATE_PRE_SDS), main_initial_action=Sequence([ recorder_for(step.SETUP__MAIN), _ActionThatSetsSymbolInSymbolTable(symbol_definition), ]), validate_post_setup_initial_action=recorder_for(step.SETUP__VALIDATE_POST_SETUP), ) ], psr.act_phase_instructions_that_does_nothing(), [ psr.before_assert_phase_instruction_that_records_a_value_per_step(recorder_for) ], [ psr.assert_phase_instruction_that_records_a_value_per_step(recorder_for) ], [ psr.cleanup_phase_instruction_that_records_a_value_per_step(recorder_for) ], ) test__va( self, test_case, Arrangement( actor=psr.actor_that_records_a_value_per_step(recorder_for, recorder_for_parse_step=psr.no_recording), predefined_symbols=predefined_symbols_table), asrt.anything_goes()) _check_result(self, expected_phase_2_step_2_names_set, actual_phase_2_step_2_names_set)
def instruction_with_usage(self, symbol_usages: list) -> SetupPhaseInstruction: return setup_phase_instruction_that(symbol_usages=do_return(symbol_usages))
def mk_setup_phase_recording_instruction(main_action: SetupMainInitialAction) -> SetupPhaseInstruction: return setup_phase_instruction_that(main_initial_action=main_action)
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup(instr.setup_phase_instruction_that( main_initial_action=append_section_name_action(self.recording_output, phase_identifier.SETUP)) )
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup( instr.setup_phase_instruction_that( main_initial_action=append_section_name_action( self.recording_output, phase_identifier.SETUP)))
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup(instr.setup_phase_instruction_that( main_initial_action=do_raise(ImplementationError()) ))
def setup_phase_instruction_that_records_a_value_per_step(recorder_for) -> SetupPhaseInstruction: return setup_phase_instruction_that( validate_pre_sds_initial_action=recorder_for(step.SETUP__VALIDATE_PRE_SDS), main_initial_action=recorder_for(step.SETUP__MAIN), validate_post_setup_initial_action=recorder_for(step.SETUP__VALIDATE_POST_SETUP), )
def instruction_that_returns(self, return_value: svh.SuccessOrValidationErrorOrHardError) -> TestCaseInstruction: return test.setup_phase_instruction_that( validate_pre_sds=do_return(return_value))
def test_one_symbol_is_defined_in_the_setup_phase(self): symbol = NameAndValue('symbol name', 'symbol value (not used in test)') all_defined_symbols = frozenset((symbol.name, )) symbol_definition = StringConstantSymbolContext( symbol.name, symbol.value).definition symbol_usages_of_instruction_that_defines_symbol = [symbol_definition] expected_phase_2_step_2_names_set = { PhaseEnum.SETUP: { step.SETUP__VALIDATE_PRE_SDS.step: all_defined_symbols, step.SETUP__MAIN.step: set(), step.SETUP__VALIDATE_POST_SETUP.step: all_defined_symbols, }, PhaseEnum.ACT: { step.ACT__VALIDATE_PRE_SDS.step: all_defined_symbols, step.ACT__VALIDATE_POST_SETUP.step: all_defined_symbols, step.ACT__EXECUTE.step: all_defined_symbols, step.ACT__PREPARE.step: all_defined_symbols, }, PhaseEnum.BEFORE_ASSERT: psr.same_value_for_all_steps(step.ALL_BEFORE_ASSERT_WITH_ENV_ARG, all_defined_symbols), PhaseEnum.ASSERT: psr.same_value_for_all_steps(step.ALL_ASSERT_WITH_ENV_ARG, all_defined_symbols), PhaseEnum.CLEANUP: psr.same_value_for_all_steps(step.ALL_CLEANUP_WITH_ENV_ARG, all_defined_symbols), } actual_phase_2_step_2_names_set = psr.new_phase_enum_2_empty_dict() def recorder_for(phase_step: SimplePhaseStep): return psr.StepRecordingAction( phase_step, actual_phase_2_step_2_names_set, get_symbols_name_set_from_instruction_environment) test_case = partial_test_case_with_instructions( [ setup_phase_instruction_that( symbol_usages=do_return( symbol_usages_of_instruction_that_defines_symbol), validate_pre_sds_initial_action=recorder_for( step.SETUP__VALIDATE_PRE_SDS), main_initial_action=sequence_of_actions([ recorder_for(step.SETUP__MAIN), _ActionThatSetsSymbolInSymbolTable(symbol_definition), ]), validate_post_setup_initial_action=recorder_for( step.SETUP__VALIDATE_POST_SETUP), ) ], psr.act_phase_instructions_that_does_nothing(), [ psr. before_assert_phase_instruction_that_records_a_value_per_step( recorder_for) ], [ psr.assert_phase_instruction_that_records_a_value_per_step( recorder_for) ], [ psr.cleanup_phase_instruction_that_records_a_value_per_step( recorder_for) ], ) test__va( self, test_case, Arrangement( psr.actor_that_records_a_value_per_step( recorder_for, recorder_for_parse_step=psr.no_recording)), asrt.anything_goes()) _check_result(self, expected_phase_2_step_2_names_set, actual_phase_2_step_2_names_set)
def setup_phase_instruction_that_records_property_of_env_for_each_step( property_recorder: PropertyRecorderBuilder) -> SetupPhaseInstruction: return setup_phase_instruction_that( validate_pre_sds_initial_action=property_recorder.of_first_arg(step.SETUP__VALIDATE_PRE_SDS), validate_post_setup_initial_action=property_recorder.of_first_arg(step.SETUP__VALIDATE_POST_SETUP), main_initial_action=property_recorder.of_first_arg(step.SETUP__MAIN))
def test_one_symbol_is_predefined_and_one_symbol_is_defined_in_the_setup_phase( self): predefined_symbol = StringSymbolContext.of_constant( 'predefined symbol', 'predefined string constant symbol value') defined_symbol = StringConstantSymbolContext( 'defined symbol', 'value of symbol defined in the setup phase (not used in this test)' ) predefined_symbols_table = predefined_symbol.symbol_table predefined_symbols = frozenset((predefined_symbol.name, )) predefined_and_defined_symbols = frozenset( (predefined_symbol.name, defined_symbol.name)) symbol_definition = defined_symbol.definition symbol_usages_of_instruction_that_defines_symbol = [symbol_definition] expected_phase_2_step_2_names_set = { PhaseEnum.SETUP: { step.SETUP__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.SETUP__MAIN.step: predefined_symbols, step.SETUP__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, }, PhaseEnum.ACT: { step.ACT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.ACT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.ACT__PREPARE.step: predefined_and_defined_symbols, step.ACT__EXECUTE.step: predefined_and_defined_symbols, }, PhaseEnum.BEFORE_ASSERT: { step.BEFORE_ASSERT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.BEFORE_ASSERT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.BEFORE_ASSERT__MAIN.step: predefined_and_defined_symbols, }, PhaseEnum.ASSERT: { step.ASSERT__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.ASSERT__VALIDATE_POST_SETUP.step: predefined_and_defined_symbols, step.ASSERT__MAIN.step: predefined_and_defined_symbols, }, PhaseEnum.CLEANUP: { step.CLEANUP__VALIDATE_PRE_SDS.step: predefined_and_defined_symbols, step.CLEANUP__MAIN.step: predefined_and_defined_symbols, }, } actual_phase_2_step_2_names_set = psr.new_phase_enum_2_empty_dict() def recorder_for(phase_step: SimplePhaseStep): return psr.StepRecordingAction( phase_step, actual_phase_2_step_2_names_set, get_symbols_name_set_from_instruction_environment) test_case = partial_test_case_with_instructions( [ setup_phase_instruction_that( symbol_usages=do_return( symbol_usages_of_instruction_that_defines_symbol), validate_pre_sds_initial_action=recorder_for( step.SETUP__VALIDATE_PRE_SDS), main_initial_action=sequence_of_actions([ recorder_for(step.SETUP__MAIN), _ActionThatSetsSymbolInSymbolTable(symbol_definition), ]), validate_post_setup_initial_action=recorder_for( step.SETUP__VALIDATE_POST_SETUP), ) ], psr.act_phase_instructions_that_does_nothing(), [ psr. before_assert_phase_instruction_that_records_a_value_per_step( recorder_for) ], [ psr.assert_phase_instruction_that_records_a_value_per_step( recorder_for) ], [ psr.cleanup_phase_instruction_that_records_a_value_per_step( recorder_for) ], ) test__va( self, test_case, Arrangement(actor=psr.actor_that_records_a_value_per_step( recorder_for, recorder_for_parse_step=psr.no_recording), predefined_symbols=predefined_symbols_table), asrt.anything_goes()) _check_result(self, expected_phase_2_step_2_names_set, actual_phase_2_step_2_names_set)
def instruction_with_usage(self, symbol_usages: list) -> SetupPhaseInstruction: return setup_phase_instruction_that(symbol_usages=do_return(symbol_usages))
def test_one_symbol_is_defined_in_the_setup_phase(self): symbol = NameAndValue('symbol name', 'symbol value (not used in test)') all_defined_symbols = frozenset((symbol.name,)) symbol_definition = data_symbol_utils.string_symbol_definition(symbol.name, symbol.value) symbol_usages_of_instruction_that_defines_symbol = [symbol_definition] expected_phase_2_step_2_names_set = { PhaseEnum.SETUP: { step.SETUP__VALIDATE_PRE_SDS.step: all_defined_symbols, step.SETUP__MAIN.step: set(), step.SETUP__VALIDATE_POST_SETUP.step: all_defined_symbols, }, PhaseEnum.ACT: { step.ACT__VALIDATE_PRE_SDS.step: all_defined_symbols, step.ACT__VALIDATE_POST_SETUP.step: all_defined_symbols, step.ACT__EXECUTE.step: all_defined_symbols, step.ACT__PREPARE.step: all_defined_symbols, }, PhaseEnum.BEFORE_ASSERT: psr.same_value_for_all_steps(step.ALL_BEFORE_ASSERT_WITH_ENV_ARG, all_defined_symbols), PhaseEnum.ASSERT: psr.same_value_for_all_steps(step.ALL_ASSERT_WITH_ENV_ARG, all_defined_symbols), PhaseEnum.CLEANUP: psr.same_value_for_all_steps(step.ALL_CLEANUP_WITH_ENV_ARG, all_defined_symbols), } actual_phase_2_step_2_names_set = psr.new_phase_enum_2_empty_dict() def recorder_for(phase_step: SimplePhaseStep): return psr.StepRecordingAction(phase_step, actual_phase_2_step_2_names_set, get_symbols_name_set_from_instruction_environment) test_case = partial_test_case_with_instructions( [ setup_phase_instruction_that( symbol_usages=do_return(symbol_usages_of_instruction_that_defines_symbol), validate_pre_sds_initial_action=recorder_for(step.SETUP__VALIDATE_PRE_SDS), main_initial_action=Sequence([ recorder_for(step.SETUP__MAIN), _ActionThatSetsSymbolInSymbolTable(symbol_definition), ]), validate_post_setup_initial_action=recorder_for(step.SETUP__VALIDATE_POST_SETUP), ) ], psr.act_phase_instructions_that_does_nothing(), [ psr.before_assert_phase_instruction_that_records_a_value_per_step(recorder_for) ], [ psr.assert_phase_instruction_that_records_a_value_per_step(recorder_for) ], [ psr.cleanup_phase_instruction_that_records_a_value_per_step(recorder_for) ], ) test__va( self, test_case, Arrangement(psr.actor_that_records_a_value_per_step(recorder_for, recorder_for_parse_step=psr.no_recording)), asrt.anything_goes()) _check_result(self, expected_phase_2_step_2_names_set, actual_phase_2_step_2_names_set)
def _setup_phase(self) -> list: return self._phase_elements( lambda main: setup_phase_instruction_that(main=main), PhaseEnum.SETUP)
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup(instr.setup_phase_instruction_that( validate_pre_sds=self.do_return_validation_error ))
populated_dir_contents = DirContents([empty_file('sds-file.txt')]) self._check( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, single_line_source(), sut.Arrangement( sds_contents_before_main=sds_populator.contents_in( sds_populator.RelSdsOptionType.REL_TMP, populated_dir_contents)), sut.Expectation( main_side_effects_on_sds=tmp_user_dir_contains_exactly( populated_dir_contents)), ) PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION = utils.ParserThatGives( setup_phase_instruction_that()) class TestSymbols(TestCaseBase): def test_that_symbols_from_arrangement_exist_in_environment(self): symbol_name = 'symbol_name_in_setup_phase' symbol_value = 'the symbol value in setup phase' symbol_table_of_arrangement = data_symbol_utils.symbol_table_with_single_string_value(symbol_name, symbol_value) expected_symbol_table = data_symbol_utils.symbol_table_with_single_string_value(symbol_name, symbol_value) assertion_for_validation = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_path_resolving_environment_that_is_first_arg)
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup( instr.setup_phase_instruction_that( main_initial_action=do_raise(ImplementationError())))
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))), ) PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION = utils.ParserThatGives( setup_phase_instruction_that()) class TestSymbols(TestCaseBase): def test_that_symbols_from_arrangement_exist_in_environment(self): symbol = StringConstantSymbolContext( 'symbol_name_in_setup_phase', 'the symbol value in setup phase') symbol_table_of_arrangement = symbol.symbol_table expected_symbol_table = symbol.symbol_table assertion_for_validation = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_path_resolving_environment_that_is_first_arg) assertion_for_main = do_fail_if_symbol_table_does_not_equal( self, expected_symbol_table, get_symbol_table_from_instruction_environment_that_is_first_arg)
def setup_instr_setup(self) -> SingleInstructionSetup: return instr_setup( instr.setup_phase_instruction_that( validate_pre_sds=self.do_return_validation_error))
def _setup_phase(self) -> list: return self._phase_elements(lambda main: setup_phase_instruction_that(main=main), PhaseEnum.SETUP)
def instruction_that_raises(self, exception: Exception) -> TestCaseInstruction: return test.setup_phase_instruction_that(symbol_usages=do_raise(exception))
def instruction_that_returns(self, return_value: svh.SuccessOrValidationErrorOrHardError) -> TestCaseInstruction: return test.setup_phase_instruction_that( validate_pre_sds=do_return(return_value))
raise SingleInstructionInvalidArgumentException('Not a symbol type: ' + type_ident) def _ref_instruction_setup(instruction_name: str, mk_instruction: Callable[[List[SymbolUsage]], model.Instruction] ) -> SingleInstructionSetup: return instruction_setup.single_instruction_setup_for_parser(instruction_name, _ReferenceParser(mk_instruction)) INSTRUCTION_SETUP = InstructionsSetup( setup_instruction_set={ DEF_INSTRUCTION_NAME: define_symbol__setup.setup(DEF_INSTRUCTION_NAME), REF_INSTRUCTION_NAME: _ref_instruction_setup( REF_INSTRUCTION_NAME, lambda usages: instrs.setup_phase_instruction_that(symbol_usages=do_return(usages))), }, before_assert_instruction_set={ DEF_INSTRUCTION_NAME: define_symbol__before_assert.setup(DEF_INSTRUCTION_NAME), REF_INSTRUCTION_NAME: _ref_instruction_setup( REF_INSTRUCTION_NAME, lambda usages: instrs.before_assert_phase_instruction_that(symbol_usages=do_return(usages))), }, assert_instruction_set={ DEF_INSTRUCTION_NAME: define_symbol__assert.setup(DEF_INSTRUCTION_NAME), REF_INSTRUCTION_NAME: _ref_instruction_setup( REF_INSTRUCTION_NAME, lambda usages: instrs.assert_phase_instruction_that(symbol_usages=do_return(usages))), }, cleanup_instruction_set={ DEF_INSTRUCTION_NAME: define_symbol__cleanup.setup(DEF_INSTRUCTION_NAME),
def instruction_that_raises(self, exception: Exception) -> TestCaseInstruction: return test.setup_phase_instruction_that(validate_pre_sds=do_raise(exception))
def instruction_that_raises(self, exception: Exception) -> TestCaseInstruction: return test.setup_phase_instruction_that(validate_pre_sds=do_raise(exception))
def mk_setup_phase_recording_instruction(main_action: Callable) -> SetupPhaseInstruction: return setup_phase_instruction_that(main_initial_action=main_action)
def mk_instruction_with_main_action(self, main_action: Callable) -> Instruction: return setup_phase_instruction_that(main_initial_action=main_action)