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()
