def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: self.registry.observation = self.env_var_to_observe in environment.proc_exe_settings.environ return sh.new_sh_success()
def prepare( self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, ) -> sh.SuccessOrHardError: self.cwd_registerer.register_cwd_for(phase_step.ACT__PREPARE) return sh.new_sh_success()
def __init__( self, parse_atc=actions.do_nothing, validate_pre_sds_action=test_actions.validate_action_that_returns( svh.new_svh_success()), validate_pre_sds_initial_action=actions.do_nothing, validate_post_setup_action=test_actions. validate_action_that_returns(svh.new_svh_success()), validate_post_setup_initial_action=actions.do_nothing, prepare_action=test_actions.prepare_action_that_returns( sh.new_sh_success()), prepare_initial_action=actions.do_nothing, execute_action=test_actions.execute_action_that_returns_exit_code( 0), execute_initial_action: BeforeExecuteMethod = actions.do_nothing, apply_action_before_atc_is_constructed=actions.do_nothing): self.apply_action_before_atc_is_constructed = apply_action_before_atc_is_constructed self.parse_atc = parse_atc self.validate_pre_sds_initial_action = validate_pre_sds_initial_action self.validate_pre_sds_action = validate_pre_sds_action self.validate_post_setup_initial_action = validate_post_setup_initial_action self.validate_post_setup_action = validate_post_setup_action self.prepare_initial_action = prepare_initial_action self.prepare_action = prepare_action self.execute_initial_action = execute_initial_action self.execute_action = execute_action
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: """ :raises: :class:`HardErrorException` """ return sh.new_sh_success()
def main(self, environment: instrs.InstructionEnvironmentForPostSdsStep, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: environment.symbols.put(self.symbol_definition.name, self.symbol_definition.resolver_container) return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: environment.proc_exe_settings.environ[self.var_name] = self.var_value return sh.new_sh_success()
def result_to_sh(result_and_stderr: ResultAndStderr) -> sh.SuccessOrHardError: result = result_and_stderr.result if not result.is_success: return sh.new_sh_hard_error(result.error_message) if result.exit_code != 0: return sh.new_sh_hard_error(failure_message_for_nonzero_status(result_and_stderr)) return sh.new_sh_success()
def cleanup_phase_instruction_that(validate_pre_sds: Callable = do_return(svh.new_svh_success()), validate_pre_sds_initial_action: Optional[Callable] = None, main: Callable = do_return(sh.new_sh_success()), main_initial_action: Optional[Callable] = None, symbol_usages_initial_action: Optional[Callable] = None, symbol_usages: Callable = do_return([])) -> CleanupPhaseInstruction: return _CleanupPhaseInstructionThat(action_of(validate_pre_sds_initial_action, validate_pre_sds), action_of(main_initial_action, main), action_of(symbol_usages_initial_action, symbol_usages))
def ret_val(environment: InstructionEnvironmentForPostSdsStep, *args): file_path = standard_phase_file_path(environment.sds.act_dir, phase) with open(str(file_path), 'w') as f: contents = os.linesep.join( file_lines_from_env(environment)) + os.linesep f.write(contents) return pfh.new_pfh_pass( ) if phase is phase_identifier.PhaseEnum.ASSERT else sh.new_sh_success( )
def prepare( self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, ) -> sh.SuccessOrHardError: try: self._construct_executor(environment, os_services) self._executor.prepare(environment) except HardErrorException as ex: return sh.new_sh_hard_error(ex.error) return sh.new_sh_success()
def __init__( self, assertion_action=do_nothing, assertion_return_value=pfh.new_pfh_pass(), non_assertion_action=do_nothing, non_assertion_return_value=sh.new_sh_success(), ): self.non_assertion_return_value = non_assertion_return_value self.non_assertion_action = non_assertion_action self.assertion_return_value = assertion_return_value self.assertion_action = assertion_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 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 __init__(self, assertion_action=do_nothing, assertion_return_value=pfh.new_pfh_pass(), non_assertion_action=do_nothing, non_assertion_return_value=sh.new_sh_success(), ): self.non_assertion_return_value = non_assertion_return_value self.non_assertion_action = non_assertion_action self.assertion_return_value = assertion_return_value self.assertion_action = assertion_action
def main(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: for k, v in self.expected_to_exist.items(): if k not in environment.environ: self.put.fail('Missing env var: ' + k) self.put.assertEqual(v, environment.environ[k], 'Env var value for var ' + k) return sh.new_sh_success()
def before_assert_phase_instruction_that(validate_pre_sds: Callable = do_return(svh.new_svh_success()), validate_pre_sds_initial_action: Optional[Callable] = None, validate_post_setup: Callable = do_return(svh.new_svh_success()), validate_post_setup_initial_action: Optional[Callable] = None, main: Callable = do_return(sh.new_sh_success()), main_initial_action: Optional[Callable] = None, symbol_usages_initial_action: Optional[Callable] = None, symbol_usages: Callable = do_return([])) -> BeforeAssertPhaseInstruction: return _BeforeAssertPhaseInstructionThat(action_of(validate_pre_sds_initial_action, validate_pre_sds), action_of(validate_post_setup_initial_action, validate_post_setup), action_of(main_initial_action, main), action_of(symbol_usages_initial_action, symbol_usages))
def cleanup_phase_instruction_that( validate_pre_sds: ValidatePreSdsAction = do_return(svh.new_svh_success()), validate_pre_sds_initial_action: Optional[Callable] = None, main: CleanupMainAction = do_return(sh.new_sh_success()), main_initial_action: Optional[CleanupMainInitialAction] = None, symbol_usages_initial_action: Optional[Callable] = None, symbol_usages: Callable = do_return([]) ) -> CleanupPhaseInstruction: return _CleanupPhaseInstructionThat( action_of(validate_pre_sds_initial_action, validate_pre_sds), action_of(main_initial_action, main), action_of(symbol_usages_initial_action, symbol_usages))
def prepare(self, environment: InstructionEnvironmentForPostSdsStep, script_output_dir_path: pathlib.Path) -> sh.SuccessOrHardError: script_file_path = self._source_file_path(script_output_dir_path) resolving_env = environment.path_resolving_environment_pre_or_post_sds source_code = self.source_code_resolver.resolve_value_of_any_dependency(resolving_env) try: with open(str(script_file_path), 'w') as f: f.write(source_code) return sh.new_sh_success() except OSError as ex: return sh.new_sh_hard_error(str(ex))
def main( self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder, ) -> sh.SuccessOrHardError: settings_builder.stdin = _StdinOfStringSource( self._contents.resolve(environment.symbols), environment.tcds, ) return sh.new_sh_success()
def __new__(cls, test_case_generator: TestCaseGeneratorForExecutionRecording, parse_action=do_nothing, validate_test_action=validate_action_that_returns(svh.new_svh_success()), prepare_test_action=prepare_action_that_returns(sh.new_sh_success()), execute_test_action=execute_action_that_returns_exit_code(), act_executor_validate_pre_sds=validate_action_that_returns(svh.new_svh_success())): return tuple.__new__(cls, (test_case_generator, validate_test_action, act_executor_validate_pre_sds, prepare_test_action, execute_test_action, parse_action))
def return_success_or_hard_error(procedure: Callable, *args, **kwargs) -> sh.SuccessOrHardError: """ Executes a callable (by invoking its __call__), and returns hard-error iff a `HardErrorException` is raised, otherwise success. :param procedure: :param args: Arguments given to callable_block :param kwargs: Arguments given to callable_block :return: success iff callable_block does not raise `HardErrorException`, otherwise success """ try: procedure(*args, **kwargs) return sh.new_sh_success() except HardErrorException as ex: return sh.new_sh_hard_error(ex.error)
def return_success_or_hard_error(callable_block, *args, **kwargs) -> sh.SuccessOrHardError: """ Executes a callable (by invoking its __call__), and returns hard-error iff a `DetectedException` is raised, otherwise success. :param callable_block: :param args: Arguments given to callable_block :param kwargs: Arguments given to callable_block :return: success iff callable_block does not raise `DetectedException`, otherwise success """ try: callable_block(*args, **kwargs) return sh.new_sh_success() except DetectedException as ex: return sh.new_sh_hard_error(ex.failure_details.failure_message)
def __new__( cls, test_case_generator: TestCaseGeneratorForExecutionRecording, actor_parse=do_nothing, atc_validate_post_setup=do_return(svh.new_svh_success()), atc_prepare=prepare_action_that_returns(sh.new_sh_success()), atc_execute: ExecuteFunctionEh = execute_action_that_returns_exit_code( ), atc_validate_pre_sds=do_return(svh.new_svh_success()), atc_symbol_usages: Callable[[], Sequence[SymbolUsage]] = do_return([])): return tuple.__new__(cls, (test_case_generator, atc_validate_post_setup, atc_prepare, atc_execute, atc_validate_pre_sds, atc_symbol_usages, actor_parse))
def __new__(cls, test_case_generator: TestCaseGeneratorForExecutionRecording, parse_action=do_nothing, validate_test_action=validate_action_that_returns( svh.new_svh_success()), prepare_test_action=prepare_action_that_returns( sh.new_sh_success()), execute_test_action: ExecuteFunctionEh = execute_action_that_returns_exit_code(), act_executor_validate_pre_sds=validate_action_that_returns( svh.new_svh_success())): return tuple.__new__( cls, (test_case_generator, validate_test_action, act_executor_validate_pre_sds, prepare_test_action, execute_test_action, parse_action))
def before_assert_phase_instruction_that( validate_pre_sds: ValidatePreSdsAction = do_return(svh.new_svh_success()), validate_pre_sds_initial_action: Optional[Callable] = None, validate_post_setup: ValidatePostSdsAction = do_return( svh.new_svh_success()), validate_post_setup_initial_action: Optional[Callable] = None, main: BeforeAssertMainAction = do_return(sh.new_sh_success()), main_initial_action: Optional[BeforeAssertMainInitialAction] = None, symbol_usages_initial_action: Optional[Callable] = None, symbol_usages: Callable = do_return([]) ) -> BeforeAssertPhaseInstruction: return _BeforeAssertPhaseInstructionThat( action_of(validate_pre_sds_initial_action, validate_pre_sds), action_of(validate_post_setup_initial_action, validate_post_setup), action_of(main_initial_action, main), action_of(symbol_usages_initial_action, symbol_usages))
def __new__(cls, test_case_generator: TestCaseGeneratorForExecutionRecording, act_executor_parse=do_nothing, act_executor_validate_post_setup=do_return(svh.new_svh_success()), act_executor_prepare=prepare_action_that_returns(sh.new_sh_success()), act_executor_execute=execute_action_that_returns_exit_code(), act_executor_validate_pre_sds=do_return(svh.new_svh_success()), act_executor_symbol_usages=do_return([]) ): return tuple.__new__(cls, (test_case_generator, act_executor_validate_post_setup, act_executor_prepare, act_executor_execute, act_executor_validate_pre_sds, act_executor_symbol_usages, act_executor_parse))
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: self.put.assertEqual(self.expected_default, environment.proc_exe_settings.environ, 'environ of proc-exe-settings') self.put.assertEqual(self.expected_default, settings.environ(), 'environ of instruction-settings') default_environ = settings.default_environ_getter() for k, v in self.expected_from_defaults_getter.items(): if k not in default_environ: self.put.fail('Missing env var: ' + k) self.put.assertEqual(v, default_environ[k], 'Env var value for var ' + k) return sh.new_sh_success()
def test_fail(self): the_error_message = 'error message' cases = [ ('is success', sh.new_sh_success(), asrt.anything_goes(), ), ('assertion on error message fails', sh.new_sh_hard_error(the_error_message), asrt.equals(the_error_message + ' - part of message not in actual'), ), ] for name, actual, assertion_on_error_message in cases: with self.subTest(name=name): # ARRANGE # assertion = sut.is_hard_error(assertion_on_error_message) # ACT # assert_that_assertion_fails(assertion, actual)
def test_fail(self): the_error_message = 'error message' cases = [ NEA('is success', asrt.anything_goes(), sh.new_sh_success(), ), NEA('assertion on error message fails', asrt_text_doc.is_single_pre_formatted_text_that_equals( the_error_message + ' - part of message not in actual' ), sh.new_sh_hard_error__str(the_error_message), ), ] for case in cases: with self.subTest(case.name): # ARRANGE # assertion = sut.is_hard_error(case.expected) # ACT # assert_that_assertion_fails(assertion, case.actual)
def __init__(self, validate_pre_sds_action=test_actions.validate_action_that_returns(svh.new_svh_success()), validate_pre_sds_initial_action=actions.do_nothing, validate_post_setup_action=test_actions.validate_action_that_returns(svh.new_svh_success()), validate_post_setup_initial_action=actions.do_nothing, prepare_action=test_actions.prepare_action_that_returns(sh.new_sh_success()), prepare_initial_action=actions.do_nothing, execute_action=test_actions.execute_action_that_returns_exit_code(0), execute_initial_action=actions.do_nothing, symbol_usages_action=actions.do_return([]) ): self.__validate_pre_sds_initial_action = validate_pre_sds_initial_action self.__validate_pre_sds_action = validate_pre_sds_action self.__validate_post_setup_initial_action = validate_post_setup_initial_action self.__validate_post_setup_action = validate_post_setup_action self.__prepare_initial_action = prepare_initial_action self.__prepare_action = prepare_action self.__execute_initial_action = execute_initial_action self.__execute_action = execute_action self.__symbol_usages_action = symbol_usages_action
def __init__(self, parse_atc=actions.do_nothing, validate_pre_sds_action=test_actions.validate_action_that_returns(svh.new_svh_success()), validate_pre_sds_initial_action=actions.do_nothing, validate_post_setup_action=test_actions.validate_action_that_returns(svh.new_svh_success()), validate_post_setup_initial_action=actions.do_nothing, prepare_action=test_actions.prepare_action_that_returns(sh.new_sh_success()), prepare_initial_action=actions.do_nothing, execute_action=test_actions.execute_action_that_returns_exit_code(0), execute_initial_action=actions.do_nothing, apply_action_before_atc_is_constructed=actions.do_nothing): self.apply_action_before_atc_is_constructed = apply_action_before_atc_is_constructed self.parse_atc = parse_atc self.validate_pre_sds_initial_action = validate_pre_sds_initial_action self.validate_pre_sds_action = validate_pre_sds_action self.validate_post_setup_initial_action = validate_post_setup_initial_action self.validate_post_setup_action = validate_post_setup_action self.prepare_initial_action = prepare_initial_action self.prepare_action = prepare_action self.execute_initial_action = execute_initial_action self.execute_action = execute_action
def __init__( self, validate_pre_sds_action=test_actions.validate_action_that_returns( svh.new_svh_success()), validate_pre_sds_initial_action=actions.do_nothing, validate_post_setup_action=test_actions.validate_action_that_returns( svh.new_svh_success()), validate_post_setup_initial_action=actions.do_nothing, prepare_action=test_actions.prepare_action_that_returns( sh.new_sh_success()), prepare_initial_action=actions.do_nothing, execute_action: ExecuteFunctionEh = test_actions. execute_action_that_returns_exit_code(0), execute_initial_action: BeforeExecuteMethod = actions.do_nothing, symbol_usages_action=actions.do_return([])): self.__validate_pre_sds_initial_action = validate_pre_sds_initial_action self.__validate_pre_sds_action = validate_pre_sds_action self.__validate_post_setup_initial_action = validate_post_setup_initial_action self.__validate_post_setup_action = validate_post_setup_action self.__prepare_initial_action = prepare_initial_action self.__prepare_action = prepare_action self.__execute_initial_action = execute_initial_action self.__execute_action = execute_action self.__symbol_usages_action = symbol_usages_action
def test_pass(self): # ARRANGE # assertion = sut.is_success() actual = sh.new_sh_success() # ACT # assertion.apply_without_message(self, actual)
def _do_record_and_return_sh(self, element): return self._do_record_and_return(element, sh.new_sh_success())
def _do_record_and_return_sh(self, element): return self._do_record_and_return(element, sh.new_sh_success())
def main(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: utils.raise_test_error_if_cwd_is_not_test_root(environment.sds) return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: environment.symbols.put(self.symbol_definition.name, self.symbol_definition.symbol_container) return sh.new_sh_success()
def configuration_phase_instruction_that(main: Callable = do_return(sh.new_sh_success()), main_initial_action: Optional[ Callable] = None) -> ConfigurationPhaseInstruction: return _ConfigurationPhaseInstructionThat(main=action_of(main_initial_action, main))
def translate_for_non_assertion(self, error_message) -> sh.SuccessOrHardError: return sh.new_sh_success()
def prepare(self, environment: InstructionEnvironmentForPostSdsStep, os_process_executor: AtcOsProcessExecutor, script_output_dir_path: pathlib.Path) -> sh.SuccessOrHardError: self.cwd_registerer.register_cwd_for(phase_step.ACT__PREPARE) return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: self.registry.observation = self.env_var_to_observe in environment.environ return sh.new_sh_success()
def _translate( error_message_or_none: Optional[TextRenderer] ) -> sh.SuccessOrHardError: if error_message_or_none is not None: return sh.new_sh_hard_error(error_message_or_none) return sh.new_sh_success()
def ret_val(environment, instruction_settings, os_services, previous_phase, *args): element = (first_value_of_pair_for_main, previous_phase) self.recorder.recording_of(element).record() return sh.new_sh_success()
def prepare( self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, ) -> sh.SuccessOrHardError: return sh.new_sh_success()
def result_to_sh(result: ExecutionResultAndStderr) -> sh.SuccessOrHardError: if result.exit_code != 0: return sh.new_sh_hard_error( top_lvl_error_msg_rendering.non_zero_exit_code_msg( result.program, result.exit_code, result.stderr_contents)) return sh.new_sh_success()
def translate_for_non_assertion(self, error_message) -> sh.SuccessOrHardError: return sh.new_sh_success() if error_message is None else sh.new_sh_hard_error(error_message)
def main(self, environment: InstructionEnvironmentForPostSdsStep, os_services: OsServices, previous_phase: PreviousPhase) -> sh.SuccessOrHardError: utils.raise_test_error_if_cwd_is_not_test_root(environment.sds) return sh.new_sh_success()
def test_pass(self): # ARRANGE # assertion = sut.is_success() actual = sh.new_sh_success() # ACT # assertion.apply_without_message(self, actual)
def ret_val(environment: common.InstructionEnvironmentForPostSdsStep, *args): file_path = standard_phase_file_path(environment.sds.act_dir, phase) with open(str(file_path), 'w') as f: contents = os.linesep.join(file_lines_from_env(environment)) + os.linesep f.write(contents) return pfh.new_pfh_pass() if phase is phase_identifier.PhaseEnum.ASSERT else sh.new_sh_success()
def main(self, configuration_builder: ConfigurationBuilder) -> sh.SuccessOrHardError: configuration_builder.set_test_case_status(self.mode_to_set) return sh.new_sh_success()
def main(self, configuration_builder: ConfigurationBuilder) -> sh.SuccessOrHardError: configuration_builder.set_timeout_in_seconds(self.timeout) return sh.new_sh_success()
def prepare(self, environment: InstructionEnvironmentForPostSdsStep, script_output_dir_path: pathlib.Path) -> sh.SuccessOrHardError: return sh.new_sh_success()
def ret_val(environment, os_services, previous_phase, *args): element = (first_value_of_pair_for_main, previous_phase) self.recorder.recording_of(element).record() return sh.new_sh_success()
def main(self, configuration_builder: ConfigurationBuilder) -> sh.SuccessOrHardError: configuration_builder.set_actor(self.actor) return sh.new_sh_success()
def translate_for_non_assertion( self, error_message: TextRenderer) -> sh.SuccessOrHardError: return (sh.new_sh_success() if error_message is None else sh.new_sh_hard_error(error_message))
def translate_for_non_assertion(self, error_message) -> sh.SuccessOrHardError: return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, previous_phase: PreviousPhase) -> sh.SuccessOrHardError: utils.raise_test_error_if_cwd_is_not_test_root(environment.sds) return sh.new_sh_success()
def main(self, environment: InstructionEnvironmentForPostSdsStep, settings: InstructionSettings, os_services: OsServices, settings_builder: SetupSettingsBuilder) -> sh.SuccessOrHardError: settings_builder.stdin = self.value_to_set return sh.new_sh_success()