def test_act(self): # ARRANGE # cases = { STEP__ACT__PARSE: { EXECUTION__INTERNAL_ERROR: ActorThatRunsConstantActions(parse_atc=DO_RAISES_EXCEPTION), }, STEP__VALIDATE_PRE_SDS: { EXECUTION__VALIDATION_ERROR: ActorThatRunsConstantActions( validate_pre_sds_action=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: ActorThatRunsConstantActions( validate_pre_sds_action=SVH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: ActorThatRunsConstantActions( validate_pre_sds_initial_action=DO_RAISES_EXCEPTION), }, } test_case_definition = test_case_definition_for(instruction_set()) test_case_source = '' for step, exit_value_2_constructor in cases.items(): for exit_value, constructor in exit_value_2_constructor.items(): expectation = Expectation(exit_value, output_is_empty) with self.subTest(step=step, exit_value=exit_value.exit_identifier): # ACT & ASSERT # _check(self, test_case_definition, constructor, test_case_source, self.sandbox_dir_resolver_that_should_not_be_called, expectation)
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_internal_error_in_act_execute(self): test_case = _single_successful_instruction_in_each_phase( single_line_sequence(72, 'ignored')) self._check( Arrangement( test_case, ActorThatRunsConstantActions( execute_action=execute_action_that_raises( test.ImplementationErrorTestException()))), Expectation( asrt_result.matches2( ExecutionFailureStatus.INTERNAL_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForPhaseFailure.new_with_exception( phase_step.ACT__EXECUTE, test.ImplementationErrorTestException)), atc_stdout_output=asrt.equals(''), atc_stderr_output=asrt.equals(''), step_recordings=[phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__ONCE + PRE_SDS_VALIDATION_STEPS__ONCE + [ phase_step.SETUP__MAIN, phase_step.SETUP__VALIDATE_POST_SETUP, phase_step.ACT__VALIDATE_POST_SETUP, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP, phase_step.ASSERT__VALIDATE_POST_SETUP, phase_step.ACT__VALIDATE_EXE_INPUT, phase_step.ACT__PREPARE, phase_step.ACT__EXECUTE, (phase_step.CLEANUP__MAIN, PreviousPhase.ACT), ], ))
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 actor_that_records_property_of_env_for_each_step_post_sds( property_recorder: PropertyRecorderBuilder) -> Actor: return ActorThatRunsConstantActions( validate_post_setup_initial_action=property_recorder.of_first_arg( step.ACT__VALIDATE_POST_SETUP), prepare_initial_action=property_recorder.of_first_arg( step.ACT__PREPARE), execute_initial_action=property_recorder.of_first_arg( step.ACT__EXECUTE), )
def test_WHEN_pass_THEN_sds_SHOULD_be_printed(self): # ARRANGE # test_case_definition = test_case_definition_for(instruction_set()) test_case_source = '' expectation = Expectation(EXECUTION__PASS, output_is_sds_which_should_be_preserved) # ACT & ASSERT # _check(self, test_case_definition, ActorThatRunsConstantActions(), test_case_source, self.sandbox_dir_resolver_of_given_dir, expectation)
def _actor(self) -> Actor: return ActorThatRunsConstantActions( validate_pre_sds_initial_action=_RecordEnvVars( self.recorder, phase_step.ACT__VALIDATE_PRE_SDS).call, validate_post_setup_initial_action=_RecordEnvVars( self.recorder, phase_step.ACT__VALIDATE_POST_SETUP).call, prepare_initial_action=_RecordEnvVars( self.recorder, phase_step.ACT__PREPARE).call, execute_initial_action=_RecordEnvVars( self.recorder, phase_step.ACT__EXECUTE).as_execute_initial_action)
def actor_that_runs_constant_actions( validate_pre_sds_action=test_actions.validate_action_that_returns(svh.new_svh_success()), validate_post_setup_action=test_actions.validate_action_that_returns(svh.new_svh_success()), prepare_action=test_actions.prepare_action_that_returns(sh.new_sh_success()), execute_action=test_actions.execute_action_that_returns_exit_code()) -> Actor: return ActorThatRunsConstantActions( validate_pre_sds_action=validate_pre_sds_action, validate_post_setup_action=validate_post_setup_action, prepare_action=prepare_action, execute_action=execute_action )
def main_program_config( tc_definition: TestCaseDefinitionForMainProgram, test_suite_definition: TestSuiteDefinition = test_suite_definition_without_instructions(), act_phase_setup: ActPhaseSetup = ActPhaseSetup( 'actor that runs constant actions', ActorThatRunsConstantActions()), ) -> MainProgramConfig: return MainProgramConfig( TestCaseHandlingSetup(act_phase_setup, IDENTITY_PREPROCESSOR), tc_definition, test_suite_definition, )
def actor_that_records_a_value_per_step( recorder_for_step_with_env: Callable, recorder_for_parse_step: Callable, ) -> Actor: return ActorThatRunsConstantActions( parse_atc=recorder_for_parse_step(step.ACT__PARSE), validate_pre_sds_initial_action=recorder_for_step_with_env( step.ACT__VALIDATE_PRE_SDS), validate_post_setup_initial_action=recorder_for_step_with_env( step.ACT__VALIDATE_POST_SETUP), prepare_initial_action=recorder_for_step_with_env(step.ACT__PREPARE), execute_initial_action=recorder_for_step_with_env(step.ACT__EXECUTE), )
def test_failing_parse(self): # ARRANGE # test_case_definition = test_case_definition_for(instruction_set()) actor = ActorThatRunsConstantActions() test_case_source = lines_content([ section_header(phase_identifier.SETUP.identifier), 'not_the_name_of_an_instruction', ]) expectation = Expectation(NO_EXECUTION__SYNTAX_ERROR, output_is_empty) # ACT & ASSERT # _check(self, test_case_definition, actor, test_case_source, self.sandbox_dir_resolver_that_should_not_be_called, expectation)
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_act(self): # ARRANGE # cases = { STEP__VALIDATE_POST_SETUP: { EXECUTION__VALIDATION_ERROR: ActorThatRunsConstantActions( validate_post_setup_action=SVH_VALIDATION_ERROR), EXECUTION__HARD_ERROR: ActorThatRunsConstantActions( validate_post_setup_action=SVH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: ActorThatRunsConstantActions( validate_post_setup_initial_action=DO_RAISES_EXCEPTION), }, STEP__ACT__PREPARE: { EXECUTION__HARD_ERROR: ActorThatRunsConstantActions(prepare_action=SH_HARD_ERROR), EXECUTION__INTERNAL_ERROR: ActorThatRunsConstantActions( prepare_initial_action=DO_RAISES_EXCEPTION), }, STEP__ACT__EXECUTE: { EXECUTION__INTERNAL_ERROR: ActorThatRunsConstantActions( execute_initial_action=DO_RAISES_EXCEPTION), }, } test_case_definition = test_case_definition_for(instruction_set()) test_case_source = '' for step, exit_value_2_constructor in cases.items(): for exit_value, actor in exit_value_2_constructor.items(): expectation = Expectation( exit_value, output_is_sds_which_should_be_preserved) with self.subTest(step=step, exit_value=exit_value.exit_identifier): # ACT & ASSERT # _check(self, test_case_definition, actor, test_case_source, self.sandbox_dir_resolver_of_given_dir, expectation)
def actor(self, recording_media: List[Recording]) -> Actor: return ActorThatRunsConstantActions()
def test_case_handling_setup_with_identity_preprocessor( ) -> TestCaseHandlingSetup: return TestCaseHandlingSetup( ActPhaseSetup('actor that does nothing', ActorThatRunsConstantActions()), IDENTITY_PREPROCESSOR)
def dummy_actor() -> Actor: return ActorThatRunsConstantActions()
def _actor(self) -> Actor: return ActorThatRunsConstantActions( validate_post_setup_action=_RecordCurrDirAndReturn(self.recorder, phase_step.ACT__VALIDATE_POST_SETUP, svh.new_svh_success()), execute_action=_RecordCurrDirAndReturn(self.recorder, phase_step.ACT__EXECUTE, new_eh_exit_code(0)))
def act_phase_setup_for_reference_instruction() -> ActPhaseSetup: return ActPhaseSetup('actor that runs constant actions', ActorThatRunsConstantActions())
SandboxRootDirNameResolver], case: Case): # ARRANGE # instruction_name = 'the_instruction' test_case_definition = test_case_definition_for( case.arrangement.instruction_setup_with_the_instruction( instruction_name)) test_case_source = lines_content([ section_header(case.arrangement.phase.identifier), instruction_name, ]) _check(put, test_case_definition, ActorThatRunsConstantActions(), test_case_source, mk_sds_resolver, case.expectation) def _check( put: unittest.TestCase, test_case_definition: TestCaseDefinitionForMainProgram, actor: Actor, test_case_source: str, mk_sds_resolver: Callable[[str], SandboxRootDirNameResolver], expectation: Expectation, ): # ARRANGE # case_file = File('the-test.case', test_case_source) source_files_dir_contents = DirContents([case_file])