def is_failure__of_indirect_reference(
failing_symbol: Assertion[str] = asrt.is_instance(str),
path_to_failing_symbol: Assertion[Sequence[str]] = asrt.is_instance(list),
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
meaning_of_failure: Assertion[
Optional[TextRenderer]] = asrt.is_none_or_instance_with(
SequenceRenderer, asrt_text_doc.is_any_text()),
) -> Assertion[Failure]:
return asrt.is_instance_with(
FailureOfIndirectReference,
asrt.and_([
asrt.sub_component('failing_symbol',
FailureOfIndirectReference.failing_symbol.fget,
failing_symbol),
asrt.sub_component(
'path_to_failing_symbol',
FailureOfIndirectReference.path_to_failing_symbol.fget,
path_to_failing_symbol),
asrt.sub_component(
'error', FailureOfIndirectReference.error.fget,
asrt_val_rest.matches_value_restriction_failure(
error_message)),
asrt.sub_component(
'meaning_of_failure',
FailureOfIndirectReference.meaning_of_failure.fget,
meaning_of_failure),
]))
def _apply(self, put: unittest.TestCase, value: T,
message_builder: MessageBuilder):
with put.assertRaises(HardErrorException) as cx:
self._method_that_should_raise(value)
asrt_text_doc.is_any_text().apply(
put,
cx.exception.error,
message_builder.for_sub_component('error message'),
)
def _apply(self, put: unittest.TestCase, value: T,
message_builder: MessageBuilder):
try:
self._method_that_should_raise(value)
put.fail('HardErrorException not raised')
except HardErrorException as ex:
asrt_text_doc.is_any_text().apply(
put,
ex.error,
message_builder.for_sub_component('error message'),
)
raise asrt.StopAssertion()
def runTest(self):
# ARRANGE #
valid_program_line = args.symbol_ref_command_line(
'PROGRAM_SYMBOL').as_str
# ACT & ASSERT #
for case in invalid_source_variants(valid_program_line):
with self.subTest(case.name):
with self.assertRaises(ParseException) as ctx:
sut.actor().parse(case.value)
asrt_text_doc.is_any_text().apply_with_message(
self, ctx.exception.cause, 'error info')
def hard_error__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_hard_error(error_message),
)
def test_regular_file(self):
file_name = 'destination.txt'
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_file_contents = str_src_abs_stx.StringSourceOfStringAbsStx.of_plain(
StringLiteralAbsStx.empty_string()
)
file_spec_syntax = regular_file_spec(
file_name_syntax,
FileContentsExplicitAbsStx(ModificationType.APPEND,
explicit_file_contents),
)
for dir_contents_case in file_must_exist_as_regular(file_name):
with self.subTest(dir_contents=dir_contents_case.name):
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_syntax]),
dir_contents_case.value,
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_destination_already_exists__without_explicit_destination(self):
# ARRANGE #
file_name = 'existing-file'
file_to_install = DirContents([(File(file_name,
'contents'))])
for parser_case in _EXECUTION_CHECKERS:
with self.subTest(parser=parser_case.name):
# ACT & ASSERT #
parser_case.value.check(
self,
args.copy(
defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(file_name)
).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY,
hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds(
file_to_install),
sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds(
DirContents([File.empty(file_name)])
),
)
),
Expectation.phase_agnostic_2(
main_result=asrt_text_doc.is_any_text(),
)
)
def hard_error_from_prepare(
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
) -> 'Expectation':
return Expectation(symbol_usages=symbol_usages,
prepare=asrt_sh.is_hard_error(error_message))
def runTest(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_TMP, 'a-dir')
unconditionally_hard_error_file_matcher = FileMatcherSymbolContext.of_primitive(
'unconditionally_hard_error_file_matcher',
matchers.MatcherThatReportsHardError())
file_in_model = 'a-file'
# ACT & ASSERT #
check_non_full_and_full(
self,
fc_args.FilesCondition([
fc_args.FileCondition(
file_in_model,
fm_args.SymbolReferenceWReferenceSyntax(
unconditionally_hard_error_file_matcher.name)),
]),
model_constructor__non_recursive(checked_dir.path_sdv),
Arrangement(
symbols=unconditionally_hard_error_file_matcher.symbol_table,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(file_in_model)])),
Expectation(
ParseExpectation(
symbol_references=asrt.matches_singleton_sequence(
unconditionally_hard_error_file_matcher.
reference_assertion)),
ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text())),
)
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,
):
raise NotImplementedError()
def test_destination_already_exists_in_destination_directory(self):
src = 'src-file-name'
dst = 'dst-dir-name'
home_dir_contents = DirContents([(File.empty(src))])
cwd_dir_contents = DirContents([Dir(dst,
[File.empty(src)])])
for parser_case in _EXECUTION_CHECKERS:
with self.subTest(parser=parser_case.name):
# ACT & ASSERT #
parser_case.value.check(
self,
args.copy(
defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(src),
defs.DEFAULT_DST_REL_OPT.path_argument_of_rel_name(dst)
).as_remaining_source,
Arrangement.phase_agnostic(
tcds=TcdsArrangement(
pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY,
hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds(
home_dir_contents),
sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds(
cwd_dir_contents
),
)
),
Expectation.phase_agnostic(
main_result=asrt_text_doc.is_any_text(),
),
)
def is_failure__of_direct_reference(
message: Assertion[TextRenderer] = asrt_text_doc.is_any_text()
) -> Assertion[Failure]:
return asrt.is_instance_with(
FailureOfDirectReference,
asrt.sub_component(
'error', FailureOfDirectReference.error.fget,
asrt_val_rest.matches_value_restriction_failure(message)))
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 expect_failure_of_main(self,
assertion_on_error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return ic.Expectation(
main_result=asrt_sh.is_hard_error(assertion_on_error_message),
symbol_usages=symbol_usages,
)
def hard_error(
expected: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
may_depend_on_external_resources: Assertion[
StringSourceContents] = external_dependencies(),
) -> 'Expectation':
return Expectation(
contents=asrt.anything_goes(),
may_depend_on_external_resources=may_depend_on_external_resources,
hard_error=asrt.is_not_none_and(expected))
def expect_failing_validation_post_setup(
self,
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return self.expect_failure_of_main(
assertion_on_error_message=error_message,
symbol_usages=symbol_usages,
)
def test_validation_SHOULD_fail_WHEN_resolved_value_is_not_an_integer(
self):
the_instruction_environment = instruction_environment.fake_pre_sds_environment(
)
test_cases = [
'a',
'1+x',
'a b',
'10 a',
'10a',
'1.5',
]
for custom_validator in [None, do_return(None)]:
for resolved_value in test_cases:
with self.subTest(
custom_validator_is_none=str(custom_validator is None),
resolved_value=resolved_value):
# ARRANGE #
sdv_to_check = sut.IntegerSdv(
string_sdvs.str_constant(resolved_value),
custom_validator)
with self.subTest(tested_obect='sdv'):
# ACT & ASSERT #
with self.assertRaises(SvhValidationException) as cm:
sdv_to_check.validate_pre_sds(
the_instruction_environment.
path_resolving_environment)
asrt_text_doc.is_any_text().apply_without_message(
self, cm.exception.err_msg)
with self.subTest(tested_obect='value'):
# ACT & ASSERT #
value_to_check = sdv_to_check.resolve(
the_instruction_environment.symbols)
actual = value_to_check.validator(
).validate_pre_sds_if_applicable(
the_instruction_environment.hds)
asrt_text_doc.is_any_text().apply_without_message(
self, actual)
def hard_error_from_execute(
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
) -> 'Expectation':
return Expectation(
symbol_usages=symbol_usages,
execute=asrt_eh.matches_hard_error(
asrt_failure_details.is_failure_message_matching__td(
error_message)))
def expect_hard_error_of_main__any(
self,
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return Expectation(
main_result=pfh_assertions.is_hard_error(
asrt_text_doc.is_any_text()),
symbol_usages=symbol_usages,
)
def expect_failing_validation_post_setup(
self,
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
symbol_usages: Assertion[
Sequence[SymbolUsage]] = asrt.is_empty_sequence,
):
return ic.Expectation(
main_result=asrt_sh.is_hard_error(error_message),
symbol_usages=symbol_usages,
)
def status_is_not_success(
expected_status: svh.SuccessOrValidationErrorOrHardErrorEnum,
error_message: Assertion[TextRenderer] = asrt_text_doc.is_any_text()
) -> Assertion[svh.SuccessOrValidationErrorOrHardError]:
return asrt.and_([
status_is(expected_status),
asrt.sub_component(
'failure_message',
svh.SuccessOrValidationErrorOrHardError.failure_message.fget,
error_message)
])
def test_invalid_executable_SHOULD_raise_hard_error(self):
# ARRANGE #
with tmp_dir.tmp_dir() as tmp_dir_path:
with self.assertRaises(HardErrorException) as ctx:
executor = sut.ProcessorThatStoresResultInFilesInDir(COMMAND_EXECUTOR,
tmp_dir_path,
file_ctx_managers.dev_null(),
)
# ACT & ASSERT #
executor.process(
ProcessExecutionSettings.null(),
command_for_exe_file(tmp_dir_path / 'non-existing-program'),
)
assert isinstance(ctx.exception, HardErrorException)
asrt_text_doc.is_any_text().apply_with_message(
self,
ctx.exception.error,
'exception error message'
)
def matches(
message: Assertion[TextRenderer]) -> Assertion[ErrorMessageWithFixTip]:
return asrt.is_instance_with(
ErrorMessageWithFixTip,
asrt.and_([
asrt.sub_component('message', ErrorMessageWithFixTip.message.fget,
message),
asrt.sub_component(
'how_to_fix', ErrorMessageWithFixTip.how_to_fix.fget,
asrt.is_none_or_instance_with(Renderer,
asrt_text_doc.is_any_text())),
]))
def hard_error(
expected: Assertion[TextRenderer] = asrt_text_doc.is_any_text(),
may_depend_on_external_resources: Assertion[
StringSourceContents] = asrt_str_src_contents.
external_dependencies(asrt.is_instance(bool)),
structure: Assertion[NodeRenderer] = asrt_trace_rendering.
matches_node_renderer(),
) -> 'ExpectationOnUnFrozenAndFrozen':
return ExpectationOnUnFrozenAndFrozen(
Expectation.hard_error(expected, may_depend_on_external_resources),
asrt.anything_goes(),
structure,
)
def runTest(self):
# ARRANGE & ACT && ASSERT #
integration_check.CHECKER__PARSE_FULL.check(
self,
args.RunProgram(
program_args.system_program_argument_elements(
NON_EXISTING_SYSTEM_PROGRAM)).as_remaining_source,
integration_check.ARBITRARY_MODEL,
arrangement_w_tcds(),
Expectation(
ParseExpectation(source=asrt_source.is_at_end_of_line(1), ),
ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text()),
),
)
def runTest(self):
# ARRANGE #
source_constructor = _SourceConstructorForStringWhoSFreezeRaisesHardError(
)
expectation = sut.ExpectationOnUnFrozenAndFrozen.hard_error(
asrt_text_doc.is_any_text(),
may_depend_on_external_resources=asrt_str_src_contents.
external_dependencies(),
)
for checker_variant in check_variants(expectation):
with self.subTest(checker_variant=checker_variant.name):
# ACT & ASSERT #
test_utils.assert_that_assertion_fails(
checker_variant.value,
sut.SourceConstructors.of_common(source_constructor),
)
def test_illegal_path_with_regular_file_as_dir_component(self):
# ARRANGE #
existing_regular_file = fs.File.empty('regular-file')
file_name = str(PurePosixPath(existing_regular_file.name, 'destination'))
file_name_syntax = StringLiteralAbsStx(file_name, QuoteType.HARD)
explicit_file_contents = str_src_abs_stx.StringSourceOfStringAbsStx.of_plain(
StringLiteralAbsStx.empty_string()
)
file_spec_cases = [
NameAndValue(
'regular',
regular_file_spec(
file_name_syntax,
FileContentsExplicitAbsStx(ModificationType.APPEND,
explicit_file_contents),
),
),
NameAndValue(
'dir',
dir_spec(
file_name_syntax,
DirContentsExplicitAbsStx(ModificationType.APPEND,
LiteralFilesSourceAbsStx(())),
),
),
]
for file_spec_case in file_spec_cases:
with self.subTest(file_spec=file_spec_case.name):
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_case.value]),
[existing_regular_file],
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_existing_file_of_invalid_type(self):
file_name = 'destination.txt'
for file_spec_case in file_must_not_exist_source_cases(file_name):
for dir_contents_case in file_must_not_exist(file_name):
with self.subTest(
file_spec=file_spec_case.name,
dir_contents=dir_contents_case.name):
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_case.value]),
dir_contents_case.value,
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_illegal_path_with_regular_file_as_dir_component(self):
# ARRANGE #
existing_regular_file = fs.File.empty('regular-file')
file_name = str(PurePosixPath(existing_regular_file.name, 'destination'))
for file_spec_case in file_must_not_exist_source_cases(file_name):
with self.subTest(file_spec=file_spec_case.name):
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_case.value]),
[existing_regular_file],
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
def test_broken_symlink(self):
# ARRANGE #
broken_sym_link = fs.sym_link('broken-symlink', 'non-existing-target')
file_name = str(PurePosixPath(broken_sym_link.name))
for file_spec_case in file_must_not_exist_source_cases(file_name):
with self.subTest(file_spec=file_spec_case.name):
# ACT & ASSERT #
integration_check.CHECKER.check__abs_stx(
self,
LiteralFilesSourceAbsStx([file_spec_case.value]),
[broken_sym_link],
arrangement_w_tcds(),
Expectation(
parse=IS_AT_END_OF_1ST_LNE,
execution=ExecutionExpectation(
is_hard_error=asrt_text_doc.is_any_text(),
)
),
)
