def test_successful_step_sequence(self):
validate_pre_sds = 'validate_pre_sds'
validate_post_sds = 'validate_post_sds'
main = 'main'
expected_recordings = [
validate_pre_sds,
validate_post_sds,
main,
]
recorder = []
def recording_of(s: str) -> Callable[[InstructionEnvironmentForPostSdsStep,
InstructionSettings,
OsServices],
None]:
def ret_val(*args):
recorder.append(s)
return ret_val
instruction_that_records_steps = instruction_embryo_that__phase_agnostic(
validate_pre_sds_initial_action=recording_of(validate_pre_sds),
validate_post_sds_initial_action=recording_of(validate_post_sds),
main_initial_action=recording_of(main))
self._check(
ParserThatGives(instruction_that_records_steps),
single_line_source(),
Arrangement.phase_agnostic(),
Expectation.phase_agnostic())
self.assertEqual(expected_recordings,
recorder,
'step execution sequence')
def test_main_method_arguments(self):
# ARRANGE #
the_environ = MappingProxyType({'the_env_var': 'the env var value'})
the_timeout = 69
the_os_services = os_services_access.new_for_current_os()
def main_action_that_checks_arguments(environment: InstructionEnvironmentForPostSdsStep,
instruction_settings: InstructionSettings,
os_services: OsServices):
self.assertIs(os_services, the_os_services, 'os_services')
self.assertEqual(the_environ, environment.proc_exe_settings.environ,
'proc exe settings/environment')
self.assertEqual(the_timeout, environment.proc_exe_settings.timeout_in_seconds,
'proc exe settings/timeout')
self.assertEqual(the_environ, instruction_settings.environ(),
'instruction settings/environment')
# ACT & ASSERT #
self._check_source_and_exe_variants(
ParserThatGives(instruction_embryo_that__phase_agnostic(
main_initial_action=main_action_that_checks_arguments
)),
Arrangement.phase_agnostic(
process_execution_settings=ProcessExecutionSettings(the_timeout, the_environ),
os_services=the_os_services,
),
MultiSourceExpectation.phase_agnostic(),
)
def test_fail_if_instruction_is_not_setup_phase_aware(self):
with self.assertRaises(utils.TestError):
self._check(
ParserThatGives(instruction_embryo_that__phase_agnostic()),
single_line_source(),
Arrangement.setup_phase_aware(),
Expectation.setup_phase_aware(),
)
def test_fail_due_to_unexpected_result__from_main(self):
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(instruction_embryo_that__phase_agnostic(main=do_return('actual'))),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
main_result=asrt.equals('different-from-actual'),
),
)
def test_succeed_due_to_expected_hard_error_exception(self):
self._check_source_and_exe_variants(
ParserThatGives(instruction_embryo_that__phase_agnostic(
main=do_raise(HardErrorException(new_single_string_text_for_test('hard error message'))))
),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
main_raises_hard_error=True
),
)
def test_fail_due_to_unexpected_hard_error_exception(self):
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(instruction_embryo_that__phase_agnostic(
main=do_raise(HardErrorException(new_single_string_text_for_test('hard error message'))))
),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
main_result=asrt.anything_goes()
),
)
def test_that_default_expectation_assumes_no_symbol_usages(self):
unexpected_symbol_usages = [
data_references.reference_to__on_direct_and_indirect('symbol_name')]
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(
instruction_embryo_that__phase_agnostic(
symbol_usages=do_return(unexpected_symbol_usages))),
Arrangement.phase_agnostic(),
Expectation.phase_agnostic(),
)
def test_that_cwd_for_main__and__validate_post_setup_is_act_dir(self):
instruction_that_raises_exception_if_unexpected_state = instruction_embryo_that__phase_agnostic(
main_initial_action=utils.raise_test_error_if_cwd_is_not_act_root__env,
validate_post_sds_initial_action=utils.raise_test_error_if_cwd_is_not_act_root__env,
)
self._check_source_and_exe_variants(
ParserThatGives(instruction_that_raises_exception_if_unexpected_state),
Arrangement.phase_agnostic(
tcds=TcdsArrangement(),
),
MultiSourceExpectation.phase_agnostic(),
)
def test_fail_if_instruction_is_not_phase_agnostic__multi(self):
with self.assertRaises(utils.TestError):
checker = sut.Checker(ParserThatGives(instruction_embryo_that__phase_agnostic()))
checker.check__abs_stx__multi__std_layouts_and_source_variants(
self.tc,
CustomAbsStx.empty(),
symbol_usages=asrt.is_empty_sequence,
execution_cases=[
NArrEx(
'the one and only case',
Arrangement.setup_phase_aware(),
ExecutionExpectation.setup_phase_aware(),
)
]
)
def test_that_fails_due_to_missing_symbol_reference(self):
symbol_usages_of_instruction = []
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(
instruction_embryo_that__phase_agnostic(
symbol_usages=do_return(symbol_usages_of_instruction))),
Arrangement.phase_agnostic(),
Expectation.phase_agnostic(
symbol_usages=asrt.matches_singleton_sequence(
matches_data_type_symbol_reference(
'symbol_name',
reference_restrictions.is_any_type_w_str_rendering()
)
)),
)
def test_symbols_populated_by_main_SHOULD_appear_in_symbol_table_given_to_symbols_after_main(self):
symbol = StringConstantSymbolContext('symbol_name', 'const string')
def add_symbol_to_symbol_table(environment: InstructionEnvironmentForPostSdsStep, *args):
environment.symbols.put(symbol.name,
symbol.symbol_table_container)
self._check_source_and_exe_variants(
ParserThatGives(
instruction_embryo_that__phase_agnostic(
main_initial_action=add_symbol_to_symbol_table)),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
symbols_after_main=asrt.sub_component('names_set',
SymbolTable.names_set.fget,
asrt.equals({symbol.name}))),
)
def test_that_symbols_from_arrangement_exist_in_environment(self):
symbol = StringConstantSymbolContext('symbol_name', 'the symbol value')
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_source_and_exe_variants(
ParserThatGives(
instruction_embryo_that__phase_agnostic(
validate_pre_sds_initial_action=assertion_for_validation,
validate_post_sds_initial_action=assertion_for_validation,
main_initial_action=assertion_for_main,
)),
Arrangement.phase_agnostic(symbols=symbol_table_of_arrangement),
MultiSourceExpectation.phase_agnostic(),
)
def test_fail_if_instruction_is_not_setup_phase_aware__source_variant(self):
self._check_source_and_exe_variants__failing_assertions(
ParserThatGives(instruction_embryo_that__phase_agnostic()),
Arrangement.setup_phase_aware(),
MultiSourceExpectation.setup_phase_aware(),
)
return self.instruction
class ParserThatConsumesCurrentLine(Generic[T], embryo.InstructionEmbryoParser[T]):
def __init__(self, parser_that_do_not_consume_any_source: embryo.InstructionEmbryoParser[T]):
self.parser_that_do_not_consume_any_source = parser_that_do_not_consume_any_source
def parse(self,
fs_location_info: FileSystemLocationInfo,
source: ParseSource) -> embryo.InstructionEmbryo[T]:
ret_val = self.parser_that_do_not_consume_any_source.parse(fs_location_info, source)
source.consume_current_line()
return ret_val
PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION = ParserThatGives(instruction_embryo_that__phase_agnostic())
class InstructionThatSetsEnvironmentVariable(embryo.PhaseAgnosticInstructionEmbryo[None]):
def __init__(self, variable: NameAndValue):
self.variable = variable
def main(self,
environment: InstructionEnvironmentForPostSdsStep,
settings: InstructionSettings,
os_services: OsServices,
):
variable = self.variable
settings.environ()[variable.name] = variable.value
