def _check_cases_for_no_lines( self, get_assertion_part_function: Callable[ [ExpectationType, LineMatcherSdv], AssertionPart[StringSource, pfh.PassOrFailOrHardError]], expected_result_when_positive_expectation: PassOrFail): empty_file_contents = '' environment = fake_post_sds_environment() os_services = new_for_current_os() matchers = [ ('unconditionally true', MatcherWithConstantResult(True)), ('unconditionally false', MatcherWithConstantResult(False)), ] with string_source_factory() as source_factory: # This test is expected to not create files using the above object, # but to be sure, one is used that creates and destroys temporary files. with tmp_file_containing(empty_file_contents) as actual_file_path: for expectation_type in ExpectationType: for matcher_name, matcher in matchers: with self.subTest(expectation_type=expectation_type, matcher_name=matcher_name): model = source_factory.of_file__poorly_described( actual_file_path) matcher_sdv = sdv_components.matcher_sdv_from_constant_primitive( matcher) assertion_part = get_assertion_part_function( expectation_type, matcher_sdv) # ACT # actual = assertion_part.check_and_return_pfh( environment, os_services, model) # ASSERT # pfh_assertion = pfh_expectation_type_config( expectation_type).main_result( expected_result_when_positive_expectation) pfh_assertion.apply_without_message(self, actual)
def test_file_matcher_reference_is_reported(self): name_of_file_matcher = 'a_file_matcher_symbol' arguments_constructor = args.complete_arguments_constructor( self.assertion_variant.arguments, file_matcher=name_of_file_matcher) arguments = arguments_constructor.apply( pfh_expectation_type_config(ExpectationType.NEGATIVE)) source = remaining_source(arguments) # ACT # matcher = parsers().full.parse(source) assert isinstance(matcher, MatcherSdv) actual = matcher.references # ASSERT # expected_references = asrt.matches_sequence( list(self.assertion_variant.expected_references) + [is_reference_to_file_matcher(name_of_file_matcher)]) expected_references.apply_without_message(self, actual) asrt_source.is_at_end_of_line(1)
def check_parsing_with_different_source_variants( self, make_instruction_arguments: InstructionArgumentsVariantConstructor, default_relativity: RelOptionType, non_default_relativity: RelOptionType, main_result_for_positive_expectation: PassOrFail, contents_of_relativity_option_root: DirContents = empty_dir_contents(), following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): rel_opt_configs = [ rel_opt_conf.default_conf_rel_any(default_relativity), rel_opt_conf.conf_rel_any(non_default_relativity), ] for rel_opt_config in rel_opt_configs: for expectation_type_of_test_case in ExpectationType: etc = pfh_expectation_type_config( expectation_type_of_test_case) instruction_arguments = make_instruction_arguments.apply( etc, rel_opt_config) for source in equivalent_source_variants__with_source_check__consume_last_line( self.put, instruction_arguments): self._check_( source, etc, main_result_for_positive_expectation, rel_opt_config, contents_of_relativity_option_root, following_symbols_setup=following_symbols_setup)
def _check_cases_with_non_empty_file(self, get_assertion_part_function: Callable[ [ExpectationType, LineMatcherSdv], FileContentsAssertionPart], actual_file_contents: str, matcher_cases: Sequence[Case]): environment = fake_post_sds_environment() os_services = new_for_current_os() with string_source_factory() as source_factory: # This test is expected to not create files using the above object, # but to be sure, one is used that creates and destroys temporary files. with tmp_file_containing(actual_file_contents) as actual_file_path: for case in matcher_cases: for expectation_type in ExpectationType: with self.subTest(case=case.name, expectation_type=expectation_type): model = source_factory.of_file__poorly_described( actual_file_path) matcher_sdv = sdv_components.matcher_sdv_from_constant_primitive( case.matcher) assertion_part = get_assertion_part_function( expectation_type, matcher_sdv) # ACT # actual = assertion_part.check_and_return_pfh( environment, os_services, model) # ASSERT # pfh_assertion = pfh_expectation_type_config( expectation_type).main_result( case. expected_result_for_positive_expectation) pfh_assertion.apply_without_message(self, actual)
def test_raise_exception_WHEN_invalid_assertion_variant(self): parser = sut.parsers(must_be_on_current_line=True).full cases = [ NameAndValue( 'Matcher is missing', args.complete_arguments_constructor( InvalidAssertionVariantArgumentsConstructor('')), ), NameAndValue( 'Matcher has invalid syntax', args.complete_arguments_constructor( InvalidAssertionVariantArgumentsConstructor( NOT_A_VALID_SYMBOL_NAME_NOR_PRIMITIVE_GRAMMAR_ELEMENT_NAME )), ), ] for case in cases: for expectation_type in ExpectationType: etc = pfh_expectation_type_config(expectation_type) instruction_arguments = case.value.apply(etc) source = remaining_source(instruction_arguments) with self.subTest(case_name=case.name, expectation_type=str(expectation_type)): with self.assertRaises( SingleInstructionInvalidArgumentException): parser.parse(source)
def runTest(self): output_from_program = 'first second' transformer_of_program = transformers_setup.DELETE_INITIAL_WORD_TRANSFORMER transformer_of_instruction = transformers_setup.DUPLICATE_WORDS_TRANSFORMER program_that_outputs_something = pgm_args.program( pgm_args.interpret_py_source_line( self.configuration.py_source_for_print(output_from_program)), transformation=transformer_of_program.name) result_when_positive = pfh_expectation_type_config( ExpectationType.POSITIVE) self._check_positive_and_negated( result_when_positive, program_that_outputs_something, matcher_arguments.equals_matcher( ab.quoted_string('second second')), lambda main_result: Expectation( main_result=main_result, symbol_usages=asrt.matches_sequence([ is_reference_to_string_transformer__usage( transformer_of_program.name), is_reference_to_string_transformer__usage( transformer_of_instruction.name), ])), arrangement=ArrangementPostAct( symbols=transformers_setup.SYMBOL_TABLE), transformation=transformer_of_instruction.name)
def runTest(self): program_that_outputs_nothing = pgm_args.program( pgm_args.interpret_py_source_line( self.configuration.py_source_for_print(''))) result_when_positive = pfh_expectation_type_config( ExpectationType.POSITIVE) self._check_positive_and_negated( result_when_positive, program_that_outputs_nothing, matcher_arguments.emptiness_matcher(), lambda main_result: Expectation(main_result=main_result))
def test_raise_exception_WHEN_selector_option_argument_is_missing(self): instruction_args_without_valid_file_matcher = args.complete_arguments_constructor( self.assertion_variant.arguments, file_matcher=' ') parser = parsers().full for expectation_type in ExpectationType: etc = pfh_expectation_type_config(expectation_type) instruction_arguments_without_valid_file_matcher_arg = instruction_args_without_valid_file_matcher.apply( etc) source = remaining_source( instruction_arguments_without_valid_file_matcher_arg) with self.subTest( arguments= instruction_arguments_without_valid_file_matcher_arg, expectation_type=str(expectation_type)): with self.assertRaises( SingleInstructionInvalidArgumentException): parser.parse(source)
def check_rel_opt_variants( self, make_instruction_arguments: InstructionArgumentsVariantConstructor, main_result_for_positive_expectation: PassOrFail, contents_of_relativity_option_root: DirContents = empty_dir_contents(), test_case_name: str = '', following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): for rel_opt_config in self.accepted_rel_opt_configurations: etc = pfh_expectation_type_config(ExpectationType.POSITIVE) instruction_arguments = make_instruction_arguments.apply( etc, rel_opt_config) self._check_(remaining_source(instruction_arguments), etc, main_result_for_positive_expectation, rel_opt_config, contents_of_relativity_option_root, test_case_name, following_symbols_setup=following_symbols_setup)
def runTest(self): program_that_outputs_something = pgm_args.program( pgm_args.interpret_py_source_line( self.configuration.py_source_for_print('some output')), transformation=transformers_setup.DELETE_EVERYTHING_TRANSFORMER. name) result_when_positive = pfh_expectation_type_config( ExpectationType.POSITIVE) self._check_positive_and_negated( result_when_positive, program_that_outputs_something, matcher_arguments.emptiness_matcher(), lambda main_result: Expectation( main_result=main_result, symbol_usages=asrt.matches_sequence([ is_reference_to_string_transformer__usage( transformers_setup.DELETE_EVERYTHING_TRANSFORMER.name), ])), ArrangementPostAct(symbols=transformers_setup.SYMBOL_TABLE))
def test_raise_exception_WHEN_there_is_an_initial_illegal_option(self): valid_instruction_arguments_con = args.complete_arguments_constructor( self.assertion_variant.arguments) parser = parsers().full for expectation_type in ExpectationType: etc = pfh_expectation_type_config(expectation_type) valid_instruction_arguments = valid_instruction_arguments_con.apply( etc) instruction_args_with_invalid_initial_option = '{invalid_option} {valid_arguments}'.format( invalid_option=long_option_syntax('illegalOption'), valid_arguments=valid_instruction_arguments, ) with self.subTest( arguments=instruction_args_with_invalid_initial_option, expectation_type=str(expectation_type)): for source in equivalent_source_variants( self, instruction_args_with_invalid_initial_option): with self.assertRaises( SingleInstructionInvalidArgumentException): parser.parse(source)
def check_rel_opt_variants_with_same_result_for_every_expectation_type( self, make_instruction_arguments: InstructionArgumentsVariantConstructor, main_result: Assertion, contents_of_relativity_option_root: DirContents = empty_dir_contents(), following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): for rel_opt_config in self.accepted_rel_opt_configurations: for expectation_type_of_test_case in ExpectationType: etc = pfh_expectation_type_config( expectation_type_of_test_case) instruction_arguments = make_instruction_arguments.apply( etc, rel_opt_config) instruction_source = remaining_source(instruction_arguments) with self.put.subTest( expectation_type=etc.expectation_type.name, arguments=instruction_arguments): instruction_check.check( self.put, self.parser, instruction_source, ArrangementPostAct( pre_contents_population_action= MAKE_CWD_OUTSIDE_OF_EVERY_REL_OPT_DIR, tcds_contents=rel_opt_config. populator_for_relativity_option_root( contents_of_relativity_option_root), symbols=_symbol_table_of(rel_opt_config.symbols, following_symbols_setup), ), Expectation( main_result=main_result, symbol_usages=asrt.matches_sequence( rel_opt_config.symbols. usage_expectation_assertions() + following_symbols_setup.expected_usages_list)))
def __init__(self, instruction_configuration: InstructionTestConfiguration, option_configuration: RelativityOptionConfiguration, expectation_type: ExpectationType): super().__init__(instruction_configuration) self.rel_opt = option_configuration self.not_opt = pfh_expectation_type_config(expectation_type)