def test_validation_pre_sds(self):
the_instruction_environment = instruction_environment.fake_pre_sds_environment()
cases = [
(
'validation should succeed when both operands succeed',
asrt_svh.is_success(),
operand_resolver_that(),
operand_resolver_that(),
),
(
'validation exception in left operand',
asrt_svh.is_validation_error(asrt.equals('error in left op')),
operand_resolver_that(
validate_pre_sds=actions.do_raise(SvhValidationException('error in left op'))),
operand_resolver_that(),
),
(
'validation exception in right operand',
asrt_svh.is_validation_error(asrt.equals('error in right op')),
operand_resolver_that(),
operand_resolver_that(
validate_pre_sds=actions.do_raise(SvhValidationException('error in right op'))),
),
(
'hard error exception in left operand',
asrt_svh.is_hard_error(asrt.equals('error in left op')),
operand_resolver_that(
validate_pre_sds=actions.do_raise(SvhHardErrorException('error in left op'))),
operand_resolver_that(),
),
(
'hard error exception in right operand',
asrt_svh.is_hard_error(asrt.equals('error in right op')),
operand_resolver_that(),
operand_resolver_that(
validate_pre_sds=actions.do_raise(SvhHardErrorException('error in right op'))),
),
]
for name, result_assertion, l_op, r_op in cases:
instruction_to_check = sut.Instruction(cmp_setup(l_op, r_op))
with self.subTest(name=name):
# ACT #
actual = instruction_to_check.validate_pre_sds(the_instruction_environment)
# ASSERT #
result_assertion.apply_without_message(self, actual)
def runTest(self):
err_msg_from_validator = 'error from validator pre sds'
name_of_referenced_symbol = 'FILES_MATCHER_SYMBOL'
expected_symbol_usages = asrt.matches_sequence(
[is_reference_to_files_matcher(name_of_referenced_symbol)])
arguments_constructor = args.CompleteArgumentsConstructor(
args.PathArgumentsConstructor('unused-path-arg'),
fm_args.argument_constructor_for_symbol_reference(name_of_referenced_symbol)
)
arguments = arguments_constructor.apply(
pfh_expectation_type_config(ExpectationType.POSITIVE),
default_conf_rel_non_home(RelNonHomeOptionType.REL_CWD),
)
cases = [
NEA('pre sds validation',
expected=
Expectation(
validation_pre_sds=asrt_svh.is_validation_error(asrt.equals(err_msg_from_validator)),
symbol_usages=expected_symbol_usages,
),
actual=
ValidatorThat(pre_sds_return_value=err_msg_from_validator)
),
NEA('post sds validation',
expected=
Expectation(
validation_post_sds=asrt_svh.is_validation_error(asrt.equals(err_msg_from_validator)),
symbol_usages=expected_symbol_usages,
),
actual=
ValidatorThat(post_setup_return_value=err_msg_from_validator)
),
]
for case in cases:
with self.subTest(case.name):
instruction_source = remaining_source(arguments)
instruction_check.check(
self,
sut.Parser(),
instruction_source,
ArrangementPostAct(
symbols=SymbolTable({
name_of_referenced_symbol:
container(FilesMatcherResolverConstantTestImpl(
resolved_value=True,
validator=case.actual,
))
}),
),
expectation=case.expected)
def runTest(self):
file_name = 'existing-plain-file'
self._check(
syntax_for_assignment_of(file_name),
Arrangement(
root_dir_contents=DirContents([File.empty(file_name)])),
Expectation(main_result=svh_assertions.is_validation_error()))
def expect_failing_validation_pre_sds(self,
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return ic.Expectation(
pre_validation_result=svh_assertions.is_validation_error(error_message),
symbol_usages=symbol_usages,
)
def test_validation_error(self):
# ARRANGE #
error_message = 'validation error'
# ACT #
actual = sut.translate_svh_exception_to_svh(test_action, DO_VALIDATION_ERROR, error_message)
# ASSERT #
expectation = asrt_svh.is_validation_error(asrt.equals(error_message))
expectation.apply_without_message(self, actual)
def test_referenced_file_does_not_exist(self):
self._run(assignment_of('{file_option} {rel_home} non-existing-file'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_home=file_ref_syntax.REL_HOME_CASE_OPTION,
)),
Arrangement(),
Expectation(pre_validation_result=svh_assertions.is_validation_error(),
source=source_is_at_end)
)
def validation_corresponding_to_dsp__post_sds_as_hard_error(path_location: DirectoryStructurePartition
) -> 'ExecutionExpectation':
if path_location is DirectoryStructurePartition.HDS:
return ExecutionExpectation(
validation_pre_sds=svh_assertions.is_validation_error()
)
else:
return ExecutionExpectation(
main_result=pfh_assertions.is_hard_error()
)
def runTest(self):
command_line = 'non-existing-file.src'
arrangement = Arrangement()
expectation = Expectation(
result_of_validate_pre_sds=svh_assertions.is_validation_error()
)
self._check(command_line,
arrangement,
expectation)
def expectation_that_file_for_actual_contents_is_invalid(conf: RelativityOptionConfiguration) -> Expectation:
if conf.exists_pre_sds:
return Expectation(
validation_pre_sds=svh_assertions.is_validation_error(),
symbol_usages=conf.symbols.usages_expectation(),
)
else:
return Expectation(
main_result=pfh_assertions.is_fail(),
symbol_usages=conf.symbols.usages_expectation(),
)
def test_referenced_file_is_a_directory(self):
self._run(assignment_of('{file_option} {rel_home} directory'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
rel_home=file_ref_syntax.REL_HOME_CASE_OPTION,
)),
Arrangement(
hds_contents=case_home_dir_contents(DirContents([empty_dir('directory')]))
),
Expectation(pre_validation_result=svh_assertions.is_validation_error(),
source=source_is_at_end)
)
def test_ERROR_when_file_does_not_exist__with_explicit_destination(self):
for relativity_option in source_relativity_options('SOURCE_SYMBOL_NAME'):
with self.subTest(msg=relativity_option.test_case_description):
self._run('{relativity_option} source-that-do-not-exist destination'.format(
relativity_option=relativity_option.option_argument),
Arrangement(
symbols=relativity_option.symbols.in_arrangement(),
),
Expectation(
pre_validation_result=svh_assertions.is_validation_error(),
symbol_usages=relativity_option.symbols.usages_expectation(),
))
def expectation_that_file_for_actual_contents_is_invalid(
conf: RelativityOptionConfiguration) -> Expectation:
if conf.exists_pre_sds:
return Expectation(
validation_pre_sds=svh_assertions.is_validation_error(),
symbol_usages=conf.symbols.usages_expectation(),
)
else:
return Expectation(
main_result=pfh_assertions.is_hard_error__with_arbitrary_message(),
symbol_usages=conf.symbols.usages_expectation(),
)
def test_validation_error(self):
# ARRANGE #
error_message = 'validation error'
# ACT #
actual = sut.translate_svh_exception_to_svh(test_action,
DO_VALIDATION_ERROR,
error_message)
# ASSERT #
expectation = asrt_svh.is_validation_error(
asrt_text_doc.is_single_pre_formatted_text_that_equals(
error_message))
expectation.apply_without_message(self, actual)
def test_executable_file_must_exist(self):
act_phase_instructions = [
instr(['non-existing-executable'])
]
arrangement = Arrangement()
expectation = Expectation(
result_of_validate_pre_sds=svh_assertions.is_validation_error()
)
check_execution(self,
sut.Parser(),
act_phase_instructions,
arrangement,
expectation)
def runTest(self):
source_file = 'source-file.src'
command_line = source_file
arrangement = Arrangement(
hds_contents=contents_in(RelHomeOptionType.REL_HOME_ACT, fs.DirContents([
fs.empty_dir(source_file)]))
)
expectation = Expectation(
result_of_validate_pre_sds=svh_assertions.is_validation_error()
)
self._check(command_line,
arrangement,
expectation)
def test_WHEN_given_validator_fails_pre_sds_THEN_validation_SHOULD_fail_pre_sds(self):
# ARRANGE #
the_error_message = 'the error message'
assertion_part = PartForValidation(ValidatorThat(
pre_sds_return_value=the_error_message))
instruction = sut.AssertionInstructionFromAssertionPart(assertion_part,
'custom environment',
lambda env: 'argument to assertion_part')
# ACT #
actual = instruction.validate_pre_sds(self.environment)
# ASSERT #
assertion = asrt_svh.is_validation_error(asrt.equals(the_error_message))
assertion.apply_without_message(self, actual)
def runTest(self):
# ARRANGE #
program_with_ref_to_file_in_hds_ds = pgm_args.program(
pgm_args.interpret_py_source_file(path_arguments.RelOptPathArgument('non-existing-file',
RelOptionType.REL_HDS_CASE))
)
arguments = po_ab.from_program(program_with_ref_to_file_in_hds_ds,
matcher_arguments.emptiness_matcher())
# ACT & ASSERT #
self._check(arguments,
ArrangementPostAct(),
Expectation(validation_pre_sds=asrt_svh.is_validation_error()))
def validation_corresponding_to__post_sds_as_hard_error(actual: ValidationActual) -> 'ExecutionExpectation':
if actual.pre_sds is not None:
return ExecutionExpectation(
validation_pre_sds=svh_assertions.is_validation_error(
asrt_text_doc.is_string_for_test_that_equals(actual.pre_sds),
)
)
elif actual.post_sds is not None:
return ExecutionExpectation(
main_result=pfh_assertions.is_hard_error(
asrt_text_doc.is_string_for_test_that_equals(actual.post_sds),
)
)
else:
return ExecutionExpectation()
def test_referenced_file_does_not_exist__rel_symbol__post_sds(self):
symbol_rel_opt = rel_opt_conf.symbol_conf_rel_any(
RelOptionType.REL_ACT,
'SYMBOL',
sut.RELATIVITY_OPTIONS_CONFIGURATION.options.accepted_relativity_variants)
self._run(assignment_of('{file_option} {relativity_option} file.txt'.format(
file_option=option_syntax(parse_here_doc_or_file_ref.FILE_ARGUMENT_OPTION),
relativity_option=symbol_rel_opt.option_argument)),
Arrangement(
symbols=symbol_rel_opt.symbols.in_arrangement(),
),
Expectation(
post_validation_result=svh_assertions.is_validation_error(),
symbol_usages=symbol_rel_opt.symbols.usages_expectation(),
source=source_is_at_end),
)
def test_executable_file_must_be_executable(self):
executable_file_name = 'existing-executable'
act_phase_instructions = [
instr([executable_file_name])
]
arrangement = Arrangement(
hds_contents=contents_in(RelHomeOptionType.REL_HOME_ACT,
fs.DirContents([fs.empty_file(executable_file_name)]))
)
expectation = Expectation(
result_of_validate_pre_sds=svh_assertions.is_validation_error()
)
check_execution(self,
sut.Parser(),
act_phase_instructions,
arrangement,
expectation)
def test_WHEN_given_validator_fails_pre_sds_THEN_validation_SHOULD_fail_pre_sds(self):
# ARRANGE #
environment = fake_post_sds_environment()
the_error_message = 'the error message'
assertion_part = PartForValidation(SdvValidatorThat(
pre_sds_return_value=asrt_text_doc.new_single_string_text_for_test(the_error_message))
)
instruction = sut.AssertionInstructionFromAssertionPart(assertion_part,
lambda env: 'argument to assertion_part')
# ACT #
actual = instruction.validate_pre_sds(environment)
# ASSERT #
assertion = asrt_svh.is_validation_error(
asrt_text_doc.is_single_pre_formatted_text_that_equals(the_error_message)
)
assertion.apply_without_message(self, actual)
def test_WHEN_given_validator_fails_post_setup_THEN_validation_SHOULD_fail_post_setup(self):
# ARRANGE #
the_error_message = 'the error message'
assertion_part = PartForValidation(ValidatorThat(
post_setup_return_value=the_error_message))
instruction = sut.AssertionInstructionFromAssertionPart(assertion_part,
'custom environment',
lambda env: 'argument to assertion_part')
# ACT #
pre_sds_result = instruction.validate_pre_sds(self.environment)
post_sds_result = instruction.validate_post_setup(self.environment)
# ASSERT #
asrt_svh.is_success().apply_with_message(self, pre_sds_result,
'pre sds validation should succeed')
assertion = asrt_svh.is_validation_error(asrt.equals(the_error_message))
assertion.apply_with_message(self, post_sds_result,
'post setup validation should fail')
def test_invalid_arguments_without_symbol_references(self):
test_cases = [
' {op} a'.format(op=comparators.EQ.name),
'{op} 1.5'.format(op=comparators.GT.name),
]
for condition_str in test_cases:
with self.subTest(msg=condition_str):
instr_arg = self._conf().arguments_constructor.apply(
condition_str)
for source in equivalent_source_variants__with_source_check__consume_last_line(
self, instr_arg):
self._check(
source,
ArrangementPostAct(),
Expectation(
validation_pre_sds=svh_asrt.is_validation_error(),
symbol_usages=asrt.is_empty_sequence,
),
)
def test_invalid_arguments_without_symbol_references(self):
test_cases = [
IntegerMatcherComparisonAbsStx.of_cmp_op__str(comparators.EQ, 'a'),
IntegerMatcherComparisonAbsStx.of_cmp_op__str(
comparators.GT, '1.5'),
]
for condition_syntax in test_cases:
with self.subTest(condition_syntax.as_str__default()):
instr_arg = self._conf().arguments_constructor.apply(
condition_syntax)
self._check(
instr_arg,
ArrangementPostAct2(),
MultiSourceExpectation(
symbol_usages=asrt.is_empty_sequence,
execution=ExecutionExpectation(
validation_pre_sds=svh_asrt.is_validation_error(),
),
),
)
def runTest(self):
cases = [
'not_an_int',
'1+not_an_int',
'1.5',
'(1',
]
actual_file_contents = 'actual file contents'
for invalid_expression in cases:
with self.subTest(invalid_value=invalid_expression):
args_variant_constructor = InstructionArgumentsVariantConstructor(
operator=comparators.NE.name,
operand=invalid_expression)
self._check_single_expression_type(
args_variant_constructor,
ExpectationType.POSITIVE,
arrangement=
self.configuration.arrangement_for_contents(
actual_file_contents),
expectation=
Expectation(validation_pre_sds=asrt_svh.is_validation_error(asrt.anything_goes()))
)
def execution_cases(
self
) -> Sequence[NExArr[ExecutionExpectation, ArrangementPostAct2]]:
return [
NExArr(
'pre sds validation',
ExecutionExpectation(
validation_pre_sds=asrt_svh.is_validation_error(
asrt_text_doc.is_string_for_test_that_equals(
self.err_msg_from_validator)), ),
self._arrangement(
DdvValidatorThat(pre_sds_return_value=asrt_text_doc.
new_single_string_text_for_test(
self.err_msg_from_validator)))),
NExArr(
'post sds validation',
ExecutionExpectation(main_result=asrt_pfh.is_hard_error(
asrt_text_doc.is_string_for_test_that_equals(
self.err_msg_from_validator)), ),
self._arrangement(
DdvValidatorThat(post_setup_return_value=asrt_text_doc.
new_single_string_text_for_test(
self.err_msg_from_validator)))),
]
def _mk_validation_assertion(
passes: bool) -> Assertion[svh.SuccessOrValidationErrorOrHardError]:
return (asrt_svh.is_success()
if passes else asrt_svh.is_validation_error())
def fails__post_sds(error_message: Assertion[TextRenderer] = asrt_text_doc.
is_any_text()) -> 'ValidationExpectationSvh':
return ValidationExpectationSvh(
pre_sds=asrt_svh.is_success(),
post_sds=asrt_svh.is_validation_error(error_message),
)
def expect_failing_validation_post_setup(self,
assertion_on_error_message: ValueAssertion = asrt.anything_goes()):
return Expectation(validation_post_sds=svh_assertions.is_validation_error(assertion_on_error_message))
def runTest(self):
self._check(
syntax_for_assignment_of('non-existing-path'), Arrangement(),
Expectation(main_result=svh_assertions.is_validation_error()))
def _svh_from_bool(
passes_validation: bool
) -> Assertion[svh.SuccessOrValidationErrorOrHardError]:
return (asrt_svh.is_success()
if passes_validation else asrt_svh.is_validation_error())
def expect_failing_validation_pre_sds(self,
assertion_on_error_message: ValueAssertion = asrt.anything_goes()):
return Expectation(validate_pre_sds_result=svh_assertions.is_validation_error(assertion_on_error_message))
def _svh_from_actual_for_test_err_msg(
actual: Optional[str]
) -> Assertion[svh.SuccessOrValidationErrorOrHardError]:
return (asrt_svh.is_success()
if actual is None else asrt_svh.is_validation_error(
asrt_text_doc.is_string_for_test_that_equals(actual)))
def post_sds_validation_fails__svh(error_message: ValueAssertion[str] = asrt.is_instance(str)
) -> ValidationExpectationSvh:
return ValidationExpectationSvh(
pre_sds=asrt_svh.is_success(),
post_sds=asrt_svh.is_validation_error(error_message),
)
def expect_failure_because_specified_file_under_sds_is_missing(
self,
symbol_usages: ValueAssertion = asrt.is_empty_sequence):
return Expectation(validation_post_sds=svh_assertions.is_validation_error(),
symbol_usages=symbol_usages)
