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