def instruction_setup_with_the_instruction(
self, instruction_name: str) -> InstructionsSetup:
instruction_setup = single_instruction_setup(instruction_name,
self.instruction)
config = dict()
setup = dict()
before_assert = dict()
assert_ = dict()
cleanup = dict()
phase_enum = self.phase.the_enum
if phase_enum is PhaseEnum.SETUP:
setup[instruction_name] = instruction_setup
elif phase_enum is PhaseEnum.BEFORE_ASSERT:
before_assert[instruction_name] = instruction_setup
elif phase_enum is PhaseEnum.ASSERT:
assert_[instruction_name] = instruction_setup
elif phase_enum is PhaseEnum.CLEANUP:
cleanup[instruction_name] = instruction_setup
else:
raise ValueError('Unhandled phase: ' + str(phase_enum))
return InstructionsSetup(config_instruction_set=config,
setup_instruction_set=setup,
before_assert_instruction_set=before_assert,
assert_instruction_set=assert_,
cleanup_instruction_set=cleanup)
def __init__(
self,
main_program_config: MainProgramConfig = main_program_execution.
main_program_config(test_case_definition_for(InstructionsSetup())),
cwd_contents: DirContents = DirContents([])):
self.main_program_config = main_program_config
self.cwd_contents = cwd_contents
def test_case_definition_with_config_phase_assertion_instruction(
put: unittest.TestCase,
hds_dir_assertion: Assertion[Path],
) -> TestCaseDefinitionForMainProgram:
return test_case_definition_for(
InstructionsSetup(
config_instruction_set={
INSTR_THAT_ASSERTS_HDS_DIR_MATCHES_PATH:
single_instruction_setup_for_parser(
INSTR_THAT_ASSERTS_HDS_DIR_MATCHES_PATH,
ConfigPhaseInstructionParserThatAssertsSourceFileLocationInfo(
put, hds_dir_assertion))
}))
def configuration_with_assert_instruction_that_fails(
instruction_name: str) -> sut.Configuration:
assert_instruction_setup = instr_setup(
instr.assert_phase_instruction_that(
main=do_return(pfh.new_pfh_fail__str('fail error message'))))
instruction_set = InstructionsSetup(
config_instruction_set={},
setup_instruction_set={},
before_assert_instruction_set={},
assert_instruction_set={instruction_name: assert_instruction_setup},
cleanup_instruction_set={},
)
return configuration_for_instruction_set(instruction_set)
def test_case_definition_with_setup_phase_assertion_instruction(
put: unittest.TestCase,
expected_default: Optional[Dict[str, str]],
expected_from_defaults_getter: Dict[str, str],
) -> TestCaseDefinitionForMainProgram:
return test_case_definition_for(
InstructionsSetup(
setup_instruction_set={
INSTR_THAT_ASSERTS_ENV_VARS:
single_instruction_setup_for_parser(
INSTR_THAT_ASSERTS_ENV_VARS,
SetupPhaseInstructionParserThatAssertsEnvVars(
put, expected_default, expected_from_defaults_getter))
}))
def test_case_definition_with_config_phase_assertion_instruction(
put: unittest.TestCase,
instruction_parser_file_loc_assertion: Assertion[FileLocationInfo],
) -> TestCaseDefinitionForMainProgram:
return test_case_definition_for(
InstructionsSetup(
config_instruction_set={
INSTR_THAT_ASSERTS_SOURCE_INFO_MATCHES_LOCATION: single_instruction_setup_for_parser(
INSTR_THAT_ASSERTS_SOURCE_INFO_MATCHES_LOCATION,
ConfigPhaseInstructionParserThatAssertsSourceFileLocationInfo(
put,
instruction_parser_file_loc_assertion))
})
)
def check_without_files(
put: unittest.TestCase,
command_line_arguments: List[str],
expectation: Assertion[SubProcessResult],
main_program_config: MainProgramConfig = main_program_execution.
main_program_config(test_case_definition_for(InstructionsSetup())),
):
# ARRANGE #
main_program = main_program_from_config(main_program_config)
# ACT #
result = capture_output_from_main_program(command_line_arguments,
main_program)
# ASSERT #
expectation.apply_without_message(put, result)
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_case_definition_with_only_assert_phase_instructions(
assert_phase_instructions: Sequence[Tuple[str, AssertPhaseInstruction]]
) -> TestCaseDefinitionForMainProgram:
assert_phase_instructions_dict = {
name: single_instruction_setup(name, instruction)
for name, instruction in assert_phase_instructions
}
return TestCaseDefinitionForMainProgram(TestCaseParsingSetup(
instruction_name_extractor_function=
instruction_name_and_argument_splitter.splitter,
instruction_setup=InstructionsSetup(
config_instruction_set={},
setup_instruction_set={},
assert_instruction_set=assert_phase_instructions_dict,
before_assert_instruction_set={},
cleanup_instruction_set={},
),
act_phase_parser=ActPhaseParser()),
builtin_symbols=[])
def test_case_definition_with_only_assert_phase_instructions(
assert_phase_instructions: Sequence[Tuple[str, AssertPhaseInstruction]]
) -> TestCaseDefinition:
assert_phase_instructions_dict = {
name: single_instruction_setup(name, instruction)
for name, instruction in assert_phase_instructions
}
return TestCaseDefinition(
TestCaseParsingSetup(
instruction_name_extractor_function=instruction_name_and_argument_splitter.splitter,
instruction_setup=InstructionsSetup(
config_instruction_set={},
setup_instruction_set={},
assert_instruction_set=assert_phase_instructions_dict,
before_assert_instruction_set={},
cleanup_instruction_set={},
),
act_phase_parser=ActPhaseParser()),
predefined_properties.new_empty(),
)
def _when_syntax_error_in_case_phase_contents_then_suite_parsing_should_raise_exception(
self):
# ARRANGE #
suite_file = File(
'the.suite',
SUITE_WITH_SYNTAX_ERROR_IN_CASE_PHASE.format(
case_phase_header=self._phase_config().phase_name().syntax))
cwd_contents = DirContents([suite_file])
tc_parsing_setup = TestCaseParsingSetup(
space_separator_instruction_name_extractor, InstructionsSetup(),
SectionElementParserThatRaisesUnrecognizedSectionElementSourceError(
))
tc_handling_setup = setup_with_null_act_phase_and_null_preprocessing()
reader = suite_hierarchy_reading.Reader(
suite_hierarchy_reading.Environment(
SectionElementParserThatRaisesUnrecognizedSectionElementSourceError(
), tc_parsing_setup, tc_handling_setup))
with self.assertRaises(SuiteParseError):
with tmp_dir_as_cwd(cwd_contents):
# ACT & ASSERT #
reader.apply(suite_file.name_as_path)
def configuration_with_instruction_in_each_phase_with_failing_validation(
instruction_name: str) -> sut.Configuration:
instr_setup_factory = InstructionWithFailingValidationFactory()
instruction_set = InstructionsSetup(
config_instruction_set={
instruction_name: instr_setup_factory.conf_instr_setup()
},
setup_instruction_set={
instruction_name: instr_setup_factory.setup_instr_setup()
},
before_assert_instruction_set={
instruction_name: instr_setup_factory.before_assert_instr_setup()
},
assert_instruction_set={
instruction_name: instr_setup_factory.assert_instr_setup()
},
cleanup_instruction_set={
instruction_name: instr_setup_factory.cleanup_instr_setup()
},
)
return configuration_for_instruction_set(instruction_set)
def configuration_with_instruction_in_each_phase_with_internal_error(
instruction_name: str) -> sut.Configuration:
instr_setup_factory = InstructionWithImplementationErrorFactory()
instruction_set = InstructionsSetup(
config_instruction_set={
instruction_name: instr_setup_factory.conf_instr_setup()
},
setup_instruction_set={
instruction_name: instr_setup_factory.setup_instr_setup()
},
before_assert_instruction_set={
instruction_name: instr_setup_factory.before_assert_instr_setup()
},
assert_instruction_set={
instruction_name: instr_setup_factory.assert_instr_setup()
},
cleanup_instruction_set={
instruction_name: instr_setup_factory.cleanup_instr_setup()
},
)
return configuration_for_instruction_set(instruction_set)
def configuration_with_instruction_in_each_phase_that_records_phase_name(
instruction_name: str,
recording_output: List[str]) -> sut.Configuration:
instr_setup_factory = PhaseRecordingInstructionFactory(recording_output)
instruction_set = InstructionsSetup(
config_instruction_set={
instruction_name: instr_setup_factory.conf_instr_setup()
},
setup_instruction_set={
instruction_name: instr_setup_factory.setup_instr_setup()
},
before_assert_instruction_set={
instruction_name: instr_setup_factory.before_assert_instr_setup()
},
assert_instruction_set={
instruction_name: instr_setup_factory.assert_instr_setup()
},
cleanup_instruction_set={
instruction_name: instr_setup_factory.cleanup_instr_setup()
},
)
return configuration_for_instruction_set(instruction_set)
from exactly_lib.cli_default.program_modes.test_case.phases import \
assert_, \
before_assert, \
cleanup, \
configuration, \
setup
from exactly_lib.processing.instruction_setup import InstructionsSetup
INSTRUCTIONS_SETUP = InstructionsSetup(configuration.INSTRUCTIONS,
setup.INSTRUCTIONS,
before_assert.INSTRUCTIONS,
assert_.INSTRUCTIONS,
cleanup.INSTRUCTIONS)
def instruction_set_with_no_instructions() -> InstructionsSetup:
return InstructionsSetup({}, {}, {}, {}, {})
INSTRUCTION_SETUP = InstructionsSetup(
config_instruction_set={
SET_ACTOR_THAT_PARSES_REFERENCES_INSTRUCTION_NAME:
_setup_for_actor_that_parses_references(
SET_ACTOR_THAT_PARSES_REFERENCES_INSTRUCTION_NAME),
UNCONDITIONALLY_HARD_ERROR_CONF_PHASE_INSTRUCTION_NAME:
_setup_hard_error_conf_phase_instruction(
UNCONDITIONALLY_HARD_ERROR_CONF_PHASE_INSTRUCTION_NAME),
},
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),
REF_INSTRUCTION_NAME:
_ref_instruction_setup(
REF_INSTRUCTION_NAME, lambda usages: instrs.
cleanup_phase_instruction_that(symbol_usages=do_return(usages))),
},
)
def mk_instruction_set_for_setup_phase(instructions: Dict[str, SingleInstructionSetup]) -> InstructionsSetup:
return InstructionsSetup(setup_instruction_set=instructions)
def instruction_setup(setup_phase_instructions: Dict[str, InstructionParser]) -> InstructionsSetup:
return InstructionsSetup({},
{name: SingleInstructionSetup(parser,
instruction_documentation('name-of-instruction'))
for name, parser in setup_phase_instructions.items()},
{}, {}, {})
def mk_instruction_set_for_phase(self, instructions: Dict[str, SingleInstructionSetup]) -> InstructionsSetup:
return InstructionsSetup(assert_instruction_set=instructions)
def instructions_setup(
self, register_instruction_name: str,
recording_media: List[Recording]) -> InstructionsSetup:
return InstructionsSetup()