def test_definition_and_reference_in_definition(self): leaf_name = 'LEAF_SYMBOL_SYMBOL' referrer_name = 'REFERRER_SYMBOL' case_with_single_def = File( 'test.case', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(leaf_name, 'value'), sym_def.define_string(referrer_name, symbol_reference_syntax_for_name(leaf_name)), ])) test_with_files_in_tmp_dir.check( self, command_line_arguments= symbol_args.arguments([case_with_single_def.name]), arrangement= Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation= asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals(output.list_of([ output.SymbolReport(leaf_name, ValueType.STRING, num_refs=1), output.SymbolReport(referrer_name, ValueType.STRING, num_refs=0), ])), ) )
def test_not_matches(self): cases = [ NEA('different keys', expected={'expected key': sut.equals('value')}, actual={'actual key': 'value'}, ), NEA('different values', expected={'key': sut.equals('expected value')}, actual={'key': 'actual value'}, ), NEA('more elements in actual than in expected', expected={1: sut.equals('value')}, actual={1: 'value', 2: 'value'}, ), NEA('more elements in expected than in actual', expected={1: sut.equals('value'), 2: sut.equals('value')}, actual={1: 'value'}, ), ] for nea in cases: with self.subTest(nea.name): assertion = sut.matches_dict(nea.expected) # ACT & ASSERT # assert_that_assertion_fails(assertion, nea.actual)
def test_single_definition_with_single_reference_in_act_phase__with_actor_set_in_conf( self): symbol_name = 'STRING_SYMBOL' case_with_single_def = File( 'test.xly', lines_content([ phase_names.CONFIGURATION.syntax, sym_def.SET_ACTOR_THAT_PARSES_REFERENCES_INSTRUCTION_NAME, phase_names.SETUP.syntax, sym_def.define_string(symbol_name, 'value'), phase_names.ACT.syntax, sym_def.reference_to(symbol_name, ValueType.STRING), ])) check_case_and_suite( self, symbol_command_arguments=[case_with_single_def.name], arrangement=Arrangement( main_program_config=sym_def.main_program_config( ActorThatRaisesParseException()), cwd_contents=DirContents([ case_with_single_def, ]), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals( output.list_of([ output.SymbolSummary(symbol_name, ValueType.STRING, num_refs=1), ])), ))
def runTest(self): # ARRANGE # may_depend_on_external_resources = False expected = 'the expected\ncontents' expected__invalid_line_sequence = ('the expected', '\ncontents') expectation = sut.ExpectationOnUnFrozenAndFrozen.equals( expected, may_depend_on_external_resources=asrt.equals(may_depend_on_external_resources), frozen_may_depend_on_external_resources=asrt.equals(may_depend_on_external_resources), ) data__valid = StringSourceData(expected, may_depend_on_external_resources) data__invalid_line_sequence = StringSourceData(expected, may_depend_on_external_resources) data__invalid_line_sequence.data__as_lines = expected__invalid_line_sequence source_constructor = self._source_constructor(data__valid, data__invalid_line_sequence) for check_variant in check_variants(expectation): with self.subTest(check_method=check_variant.name): # ACT & ASSERT # test_utils.assert_that_assertion_fails( check_variant.value, sut.SourceConstructors.of_common(source_constructor), )
def assertion(self) -> Assertion[ParseSource]: return (asrt_source.is_at_end_of_line(self.current_line_number) if self.remaining_part_of_current_line is None else asrt_source.source_is_not_at_end( current_line_number=asrt.equals(self.current_line_number), remaining_part_of_current_line=asrt.equals( self.remaining_part_of_current_line)))
def test(self): name_of_existing_symbol = 'STRING_SYMBOL' case_with_single_def = File('test.case', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(name_of_existing_symbol, 'value'), ])) expected_first_line = output.list_of([output.SymbolReport(name_of_existing_symbol, ValueType.STRING, num_refs=0)]).rstrip() test_with_files_in_tmp_dir.check( self, command_line_arguments= symbol_args.individual__definition( case_with_single_def.name, name_of_existing_symbol, ), arrangement= Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation= asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt_str.first_line(asrt.equals(expected_first_line))) )
def equals_node(expected: Node) -> Assertion[Node]: return matches_node( header=asrt.equals(expected.header), data=asrt.equals(expected.data), details=equals_details(expected.details), children=equals_nodes(expected.children), )
def is_skipped() -> ValueAssertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.SKIPPED), failure_info=asrt.is_none, has_sds=asrt.equals(False), sds=asrt.is_none, has_action_to_check_outcome=asrt.equals(False), action_to_check_outcome=asrt.is_none)
def test_single_definition_in_default_suite_file(self): symbol_name = 'STRING_SYMBOL' suite_with_single_def = File( DEFAULT_SUITE_FILE, lines_content([ phase_names.SETUP.syntax, sym_def.define_string(symbol_name, 'value'), ])) dir_arg = Dir('a-dir', [suite_with_single_def]) test_with_files_in_tmp_dir.check( self, command_line_arguments=symbol_args.arguments__suite([dir_arg.name ]), arrangement=Arrangement( cwd_contents=DirContents([ dir_arg, ]), main_program_config=sym_def.main_program_config(), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals( output.list_of([ output.SymbolSummary(symbol_name, ValueType.STRING, num_refs=0), ])), ))
def test(self): cases = [ Case('empty line with no following lines', source= remaining_source(''), expectation= Expectation(elements=[], source=asrt_source.is_at_end_of_line(1)), ), Case('only white space on current line, with no following lines', source= remaining_source(' '), expectation= Expectation(elements=[], source=asrt_source.source_is_not_at_end( current_line_number=asrt.equals(1), remaining_part_of_current_line=asrt.equals(' '))), ), Case('empty line, with following lines', source= remaining_source('', ['contents of following line']), expectation= Expectation(elements=[], source=asrt_source.is_at_end_of_line(1), ) ), ] # ACT & ASSERT # _test_cases(self, cases)
def test_contents_is_larger_than_mem_buff(self): # ARRANGE # mem_buff_size = 4 cases = [ NameAndValue( 'single line', 'abc' * mem_buff_size, ), NameAndValue( 'multi line', '1st\n2nd\n' * mem_buff_size, ), ] for case in cases: with self.subTest(case.name): source_constructor = _SourceConstructorOfUnfrozenAsConstStr( case.value, mem_buff_size) expectation = multi_obj_assertions.ExpectationOnUnFrozenAndFrozen.equals( ''.join(source_constructor.contents), may_depend_on_external_resources=asrt.equals(False), frozen_may_depend_on_external_resources=asrt.equals(True), ) assertion = multi_obj_assertions.assertion_of_sequence_permutations( expectation) # ACT & ASSERT # assertion.apply_without_message( self, multi_obj_assertions.SourceConstructors.of_common( source_constructor), )
def test_implementation_error_in_act_execute(self): test_case = _single_successful_instruction_in_each_phase(single_line_sequence(72, 'ignored')) self._check( Arrangement(test_case, ActorThatRunsConstantActions( execute_action=execute_action_that_raises( test.ImplementationErrorTestException()))), Expectation( asrt_result.matches2(PartialExeResultStatus.IMPLEMENTATION_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForPhaseFailure.new_with_exception( phase_step.ACT__EXECUTE, test.ImplementationErrorTestException) ), atc_stdout_output=asrt.equals(''), atc_stderr_output=asrt.equals(''), step_recordings= [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__ONCE + PRE_SDS_VALIDATION_STEPS__ONCE + [phase_step.SETUP__MAIN, phase_step.SETUP__VALIDATE_POST_SETUP, phase_step.ACT__VALIDATE_POST_SETUP, phase_step.BEFORE_ASSERT__VALIDATE_POST_SETUP, phase_step.ASSERT__VALIDATE_POST_SETUP, phase_step.ACT__PREPARE, phase_step.ACT__EXECUTE, (phase_step.CLEANUP__MAIN, PreviousPhase.ACT), ], ))
def test_not_matches(self): # ARRANGE # expected_instruction = Instruction() expected_description = 'the description' instruction_info = InstructionInfo(expected_instruction, expected_description) expected_source = LineSequence(1, ('expected',)) actual_element = ParsedInstruction(expected_source, instruction_info) cases = [ NameAndValue('mismatch on source', sut.matches_instruction(asrt.not_(equals_line_sequence(expected_source)), matches_instruction_info(asrt.equals(expected_description), asrt.is_(expected_instruction))) ), NameAndValue('mismatch on description', sut.matches_instruction(equals_line_sequence(expected_source), matches_instruction_info(asrt.not_(asrt.equals(expected_description)), asrt.is_(expected_instruction))) ), NameAndValue('mismatch on instruction', sut.matches_instruction(equals_line_sequence(expected_source), matches_instruction_info(asrt.not_(asrt.equals(expected_description)), asrt.not_(asrt.is_(expected_instruction)))) ), ] for nav in cases: with self.subTest(nav.name): # ACT & ASSERT # assert_that_assertion_fails(nav.value, actual_element)
def runTest(self): # ARRANGE # arguments = names.IDENTITY_TRANSFORMER_NAME model_content_lines = ['the model contents line 1'] # ACT & ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants( self, Arguments(arguments), model_constructor.of_lines(self, model_content_lines), arrangement_w_tcds(), Expectation( ParseExpectation( symbol_references=asrt.is_empty_sequence, ), ExecutionExpectation( main_result=asrt_string_source.pre_post_freeze__matches_lines__identical( asrt.equals(model_content_lines), may_depend_on_external_resources=asrt.equals(False), ) ), prim_asrt__constant(is_identity_transformer(True)), adv=freeze_check.first_invoked_method_of_source_model__is_freeze, ) )
def runTest(self): # ARRANGE # source_file = fs.File.empty('source-file.src') python_interpreter_symbol = PathSymbolContext.of_sdv( 'PYTHON_INTERPRETER_SYMBOL', path_sdvs.constant( path_ddvs.absolute_path(pathlib.Path(sys.executable)))) interpreter_with_symbol_reference = command_sdvs.for_executable_file( python_interpreter_symbol.reference_sdv__path_or_string( relativity_configurations.INTERPRETER_FILE.relativity)) arrangement = arrangement_w_tcds( symbol_table=python_interpreter_symbol.symbol_table, hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([source_file]))) expectation = Expectation( symbol_usages=asrt.matches_singleton_sequence( python_interpreter_symbol.reference_assertion__path_or_string), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=asrt_pr.sub_process_result( exitcode=asrt.equals(0), stdout=asrt.equals(''), stderr=asrt.equals(''), )), ) # ACT & ASSERT # check_execution(self, sut.actor(interpreter_with_symbol_reference), [instr([])], arrangement, expectation)
def test_parse(self): pattern = 'include*' space = ' ' cases = [ SourceCase('single name argument', remaining_source(name_glob_pattern_matcher_of(pattern)), assert_source(is_at_eof=asrt.is_true), ), SourceCase('single name argument followed by space, and following lines', remaining_source(name_glob_pattern_matcher_of(pattern) + space, ['following line']), assert_source(current_line_number=asrt.equals(1), remaining_part_of_current_line=asrt.equals(space[1:])), ), SourceCase('single name argument followed by arguments', remaining_source(name_glob_pattern_matcher_of(pattern) + space + 'following argument', ['following line']), assert_source(current_line_number=asrt.equals(1), remaining_part_of_current_line=asrt.equals(space[1:] + 'following argument')), ), ] for case in cases: with self.subTest(case=case.name): self._check_parse( case.source, Expectation( resolved_value_equals_file_matcher(file_matchers.FileMatcherNameGlobPattern(pattern)), source=case.source_assertion, ) )
def visit_string(self, expected: StringText): self._assert_is_type(StringText) actual = self.actual assert isinstance(actual, StringText) asrt.equals(expected.value).apply( self.put, actual.value, self.message_builder.for_sub_component('value'))
def type_is_file_on_disk( path_of_file_on_disk: Assertion[pathlib.Path], fileno: Assertion[int] = asrt.anything_goes(), ) -> Assertion[sut.SpooledTextFile]: return asrt.and_([ asrt.sub_component( 'is_mem_buff', sut.SpooledTextFile.is_mem_buff.fget, asrt.equals(False), ), asrt.sub_component( 'is_file_on_disk', sut.SpooledTextFile.is_file_on_disk.fget, asrt.equals(True), ), asrt.sub_component( 'fileno', sut.SpooledTextFile.fileno, asrt.is_instance_with(int, fileno), ), asrt.sub_component( 'path_of_file_on_disk', sut.SpooledTextFile.path_of_file_on_disk.fget, path_of_file_on_disk, ), ])
def ret_val(tcds: TestCaseDs) -> Assertion[Command]: return asrt_command.matches_command( asrt_command.matches_executable_file_command_driver( asrt.equals(tcds.hds.case_dir / interpreter_exe_file) ), asrt.equals(arguments + [str(tcds.hds.act_dir / source_file_relative_hds_name)]) )
def test_hard_error_in_setup_main_step(self): py_pgm_setup = PyProgramSetup('some output to stdout', 'some output to stderr', 72) test_case = TestCaseGeneratorWithExtraInstrsBetweenRecordingInstr( act_phase_source=py_pgm_setup.as_line_sequence()) \ .add(PartialPhase.SETUP, test.setup_phase_instruction_that( main=do_return(sh.new_sh_hard_error('hard error msg from setup')))) self._check( arr_for_py3_source(test_case), Expectation( asrt_result.matches2( PartialExeResultStatus.HARD_ERROR, asrt_result.has_sds(), asrt_result.has_no_action_to_check_outcome(), ExpectedFailureForInstructionFailure.new_with_message( phase_step.SETUP__MAIN, test_case.the_extra(PartialPhase.SETUP)[0].source, 'hard error msg from setup'), ), atc_stdout_output=asrt.equals(''), atc_stderr_output=asrt.equals(''), step_recordings= [phase_step.ACT__PARSE] + SYMBOL_VALIDATION_STEPS__TWICE + PRE_SDS_VALIDATION_STEPS__TWICE + [phase_step.SETUP__MAIN, (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), (phase_step.CLEANUP__MAIN, PreviousPhase.SETUP), ], ))
def ret_val(tcds: TestCaseDs) -> Assertion[Command]: return asrt_command.matches_command( asrt_command.matches_executable_file_command_driver( asrt.equals(tcds.hds.case_dir / interpreter_exe_file) ), matches_elements_except_last(asrt.equals(arguments)) )
def test_relative_path_to_root_file_in_sub_dir_of_cwd(self): # ARRANGE # root_file_sub_dir_path = Path('sub-dir') root_file_in_sub_dir = file_with_lines('root-file-base-name.src', [ phase_names.CONFIGURATION.syntax, INSTR_THAT_ASSERTS_SOURCE_INFO_MATCHES_LOCATION, ]) cwd_dir_contents = DirContents([ Dir(str(root_file_sub_dir_path), [ root_file_in_sub_dir, ]) ]) file_arg_to_parser_rel_cwd = root_file_sub_dir_path / root_file_in_sub_dir.name with tmp_dir_as_cwd(cwd_dir_contents) as abs_cwd_dir_path: instruction_parser_file_loc_assertion = matches_file_location_info( abs_path_of_dir_containing_first_file_path=asrt.equals(abs_cwd_dir_path), file_path_rel_referrer=asrt.equals(file_arg_to_parser_rel_cwd), file_inclusion_chain=asrt.is_empty_sequence, ) # ACT & ASSERT # fail_if_test_case_does_not_pass( self, file_arg_to_parser_rel_cwd, test_case_definition_with_config_phase_assertion_instruction(self, instruction_parser_file_loc_assertion))
def equals(expected: Element) -> Assertion[Element]: return asrt.and_([ asrt.sub_component( 'tag', _get_element_tag, asrt.equals(expected.tag), ), asrt.sub_component( 'attributes', _get_element_attrib, asrt.equals(expected.attrib), ), asrt.sub_component( 'text', _get_element_text, _text_assertion__none_eq_empty_str(expected.text), ), asrt.sub_component( 'tail', _get_element_tail, _text_assertion__none_eq_empty_str(expected.tail), ), asrt.sub_component( 'children', _get_element_children, asrt.matches_sequence__named([ NameAndValue(repr(child.tag), equals(child)) for child in list(expected) ]), ), ])
def test_single_reference_in_act_phase(self): name_of_existing_symbol = 'STRING_SYMBOL' reference_source = sym_def.reference_to(name_of_existing_symbol, ValueType.STRING) case_with_single_def = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(name_of_existing_symbol, 'value'), phase_names.ACT.syntax, reference_source, ])) expected_reference_output = output.Reference(phase_identifier.ACT, None, [ reference_source, ]) check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_with_single_def.name, name_of_existing_symbol, ), arrangement=Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals( lines_content(expected_reference_output.output_lines()))))
def is_skipped() -> Assertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.SKIPPED), failure_info=asrt.is_none, has_sds=asrt.equals(False), sds=asrt.is_none, has_action_to_check_outcome=asrt.equals(False), action_to_check_outcome=asrt.is_none)
def _equals_empty_node(expected: Node) -> Assertion[Node]: return asrt_d_tree.matches_node( header=asrt.equals(expected.header), data=asrt.equals(expected.data), details=asrt.is_empty_sequence, children=asrt.is_empty_sequence, )
def runTest(self): # ARRANGE # program_symbol = StringConstantSymbolContext( 'program_name_symbol', 'the-program', default_restrictions=asrt_rest.is__string__w_all_indirect_refs_are_strings(), ) argument_list_symbol = ListConstantSymbolContext( 'arguments_symbol', ['1st', '2nd'], ) symbols = [program_symbol, argument_list_symbol] expected_command = asrt_command.matches_command( driver=asrt_command.matches_system_program_command_driver( asrt.equals(program_symbol.str_value) ), arguments=asrt.equals(argument_list_symbol.constant), ) # ACT & ASSERT # check_successful_execution( self, arguments=command_line( program_symbol.name__sym_ref_syntax, program_arguments.simple(argument_list_symbol.name__sym_ref_syntax), ), expected_command=expected_command, symbols=SymbolContext.symbol_table_of_contexts(symbols), symbol_usages=SymbolContext.usages_assertion_of_contexts(symbols) )
def test_not_matches(self): cases = [ NEA( 'color - different values', expected=sut.matches_text_style(color=asrt.equals( ForegroundColor.GREEN), ), actual=TextStyle(ForegroundColor.RED, None), ), NEA( 'color - actual is None', expected=sut.matches_text_style(color=asrt.equals( ForegroundColor.GREEN), ), actual=TextStyle(None, None), ), NEA( 'font_style - different values', expected=sut.matches_text_style(font_style=asrt.equals( FontStyle.UNDERLINE), ), actual=TextStyle(None, FontStyle.BOLD), ), NEA( 'font_style - actual is None', expected=sut.matches_text_style(font_style=asrt.equals( FontStyle.UNDERLINE), ), actual=TextStyle(None, None), ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(case.expected, case.actual)
def test_hard_error(self): the_instruction_environment = instruction_environment.fake_post_sds_environment() the_os_services = os_services.new_default() cases = [ ( 'hard error exception in left operand', asrt_pfh.is_hard_error(asrt.equals('error error in left op')), operand_resolver_that( resolve_return_value_action=actions.do_raise(PfhHardErrorException('error error in left op'))), operand_resolver_that(), ), ( 'hard error exception in right operand', asrt_pfh.is_hard_error(asrt.equals('error error in right op')), operand_resolver_that(), operand_resolver_that( resolve_return_value_action=actions.do_raise(PfhHardErrorException('error 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.main(the_instruction_environment, the_os_services) # ASSERT # result_assertion.apply_without_message(self, actual)
def test_matches(self): cases = [ NEA( 'default', expected=sut.matches_element_properties(), actual=ElementProperties(Indentation(1, ''), TEXT_STYLE__NEUTRAL), ), NEA( 'indentation', expected=sut.matches_element_properties( indentation=sut.matches_indentation( level=asrt.equals(69)), ), actual=ElementProperties(Indentation(69, ''), TEXT_STYLE__NEUTRAL), ), NEA( 'text_style', expected=sut.matches_element_properties( text_style=sut.matches_text_style( color=asrt.equals(ForegroundColor.GREEN)), ), actual=ElementProperties( INDENTATION__NEUTRAL, TextStyle(ForegroundColor.GREEN, None)), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def runTest(self): # ARRANGE # for transformation_may_depend_on_external_resources in [False, True]: with self.subTest(transformation_may_depend_on_external_resources= transformation_may_depend_on_external_resources): source_constructor = _SourceConstructorOfTransFun( _transformer_function, [ '1st\n', '2nd\n', ], transformation_may_depend_on_external_resources, ) expectation = multi_obj_assertions.ExpectationOnUnFrozenAndFrozen.equals( ''.join(_transformer_function(source_constructor.lines)), may_depend_on_external_resources=asrt.equals( transformation_may_depend_on_external_resources), frozen_may_depend_on_external_resources=asrt.equals( transformation_may_depend_on_external_resources), ) assertion = multi_obj_assertions.assertion_of_sequence_permutations( expectation) # ACT & ASSERT # assertion.apply_without_message( self, multi_obj_assertions.SourceConstructors.of_common( source_constructor), )
def test_glob_pattern(self): match_anything_glob_pattern_string_symbol = StringSymbolContext.of_constant( 'glob_pattern_symbol', '*', default_restrictions=glob_pattern.is_reference_restrictions__glob_pattern_string() ) arguments = self.conf.arguments( NameGlobPatternVariant(match_anything_glob_pattern_string_symbol.name__sym_ref_syntax) ) integration_check.CHECKER__PARSE_SIMPLE.check__w_source_variants( self, arguments= arguments.as_arguments, input_= ARBITRARY_MODEL, arrangement=arrangement_wo_tcds( symbols=match_anything_glob_pattern_string_symbol.symbol_table ), expectation=Expectation( ParseExpectation( symbol_references=asrt.matches_sequence([ match_anything_glob_pattern_string_symbol.reference_assertion, ]), ), ExecutionExpectation( main_result=asrt_matching_result.matches_value__w_header( asrt.equals(True), asrt.equals(self.conf.node_name) ) ), ) )
def test_path_argument_SHOULD_use_posix_syntax(self): # ARRANGE # inclusion_directive_name = 'incl-directive' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) path_arg = pathlib.PurePosixPath('first') / 'second' inclusion_directive_line = inclusion_directive_name + ' ' + str(path_arg) source = source_of_lines([ inclusion_directive_line, 'second line', ]) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # expected_directive = is_file_inclusion_directive( matches_file_inclusion_directive( files_to_include=asrt.matches_sequence([ asrt.equals(pathlib.Path(path_arg)), ]), source=matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence([ asrt.equals(inclusion_directive_line) ])) )) expected_directive.apply_with_message(self, actual, 'parsed directive') expected_source = is_at_beginning_of_line(2) expected_source.apply_with_message(self, source, 'source')
def test_matches(self): cases = [ NEA( 'default 1', expected=sut.matches_text_style(), actual=TextStyle(None, None), ), NEA( 'default/w color', expected=sut.matches_text_style(), actual=TextStyle(ForegroundColor.GREEN, None), ), NEA( 'default/w style', expected=sut.matches_text_style(), actual=TextStyle(None, FontStyle.BOLD), ), NEA( 'color', expected=sut.matches_text_style(color=asrt.equals( ForegroundColor.GREEN), ), actual=TextStyle(ForegroundColor.GREEN, None), ), NEA( 'font_style', expected=sut.matches_text_style(font_style=asrt.equals( FontStyle.BOLD), ), actual=TextStyle(None, FontStyle.BOLD), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def check_exception(self, root_path: pathlib.Path, actual: Exception, put: unittest.TestCase): put.assertIsInstance(actual, SuiteParseError) expected_source = single_line_sequence(2, self.file_inclusion_line) expectation = matches_suite_parse_error( suite_file=asrt.equals(self.root_suite_based_at(root_path)), maybe_section_name=asrt.equals(phase_names.SETUP.plain), source=equals_line_sequence(expected_source), source_location=equals_source_location_path( SourceLocationPath( SourceLocation( expected_source, self.root_suite_file, ), [] ) ), document_parser_exception=asrt.is_instance(sec_doc_exceptions.FileAccessError), ) expectation.apply(put, actual)
def test_WHEN_source_does_start_with_directive_name_but_invalid_number_of_arguments_follows_THEN_exception_SHOULD_be_raised( self): # ARRANGE # inclusion_directive_name = 'include' parser = sut.FileInclusionDirectiveParser(inclusion_directive_name) cases = [ NameAndValue('missing argument', inclusion_directive_name, ), NameAndValue('superfluous arguments', inclusion_directive_name + ' arg1 superfluous', ), ] for case in cases: with self.subTest(case.name): source = source_of_lines([ case.value, 'second line', ]) # ACT # with self.assertRaises(RecognizedSectionElementSourceError) as cm: # ACT & ASSERT # parser.parse(ARBITRARY_FS_LOCATION_INFO, source) actual_exception = cm.exception assert isinstance(actual_exception, SectionElementError) expected_invalid_source = matches_line_sequence( first_line_number=asrt.equals(1), lines=asrt.matches_sequence([ asrt.equals(case.value) ])) expected_invalid_source.apply_with_message(self, actual_exception.source, 'source')
def test_definition_and_reference_in_definition(self): leaf_name = 'LEAF_SYMBOL_SYMBOL' referrer_name = 'REFERRER_SYMBOL' case_with_single_def = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(leaf_name, 'value'), sym_def.define_string( referrer_name, symbol_reference_syntax_for_name(leaf_name)), ])) check_case_and_suite( self, symbol_command_arguments=[case_with_single_def.name], arrangement=Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals( output.list_of([ output.SymbolSummary(leaf_name, ValueType.STRING, num_refs=1), output.SymbolSummary(referrer_name, ValueType.STRING, num_refs=0), ])), ))
def test_matches(self): value1 = 'a value' value2 = 'a value' cases = [ NEA('empty', expected=[], actual=[], ), NEA('single element / list', expected=[sut.equals(value1)], actual=[value1], ), NEA('single element / tuple', expected=(sut.equals(value1),), actual=(value1,), ), NEA('many values', expected=[sut.equals(value1), sut.equals(value2)], actual=[value1, value2], ), ] for nea in cases: with self.subTest(nea.name): assertion = sut.matches_sequence(nea.expected) # ACT & ASSERT # assertion.apply_without_message(self, nea.actual)
def test_single_definition_with_reference_to_builtin_symbol(self): builtin_symbol = StringSymbolContext.of_constant( 'BUILTIN_STRING_SYMBOL', 'builtin string symbol value') user_defined_symbol_name = 'STRING_SYMBOL' case_with_single_def = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string( user_defined_symbol_name, symbol_reference_syntax_for_name(builtin_symbol.name)), ])) check_case_and_suite( self, symbol_command_arguments=[case_with_single_def.name], arrangement=Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config( builtin_symbols=[ sym_def.builtin_symbol(builtin_symbol), ]), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals( output.list_of([ output.SymbolSummary(user_defined_symbol_name, ValueType.STRING, num_refs=0), ])), ))
def test_not_equals(self): cases = [ NEA( 'unexpected driver type', expected=sut.matches_command( sut.equals_shell_command_driver( CommandDriverForShell('command')), asrt.equals(['arg'])), actual=Command(CommandDriverForSystemProgram('command'), ['arg']), ), NEA( 'unexpected driver data', expected=sut.matches_command( sut.equals_system_program_command_driver( CommandDriverForSystemProgram('expected')), asrt.equals([])), actual=Command(CommandDriverForSystemProgram('unexpected'), []), ), NEA( 'unexpected argument', expected=sut.matches_command( sut.equals_system_program_command_driver( CommandDriverForSystemProgram('command')), asrt.equals(['expected'])), actual=Command(CommandDriverForSystemProgram('command'), ['expected', 'unexpected']), ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(case.expected, case.actual)
def test_matches(self): expected_string = 'expected string' cases = [ NEA( 'default/False', expected=sut.is_string(), actual=StringLineObject('anything', False), ), NEA( 'default/True', expected=sut.is_string(), actual=StringLineObject('anything', True), ), NEA('string', expected=sut.is_string(string=asrt.equals(expected_string)), actual=StringLineObject(expected_string, True)), NEA( 'string is line ended', expected=sut.is_string(string_is_line_ended=asrt.equals(True)), actual=StringLineObject('anything', True), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def runTest(self): # ARRANGE # cases = [ NameAndValue( 'empty', '', ), NameAndValue( 'single line', 'abc', ), NameAndValue( 'multi line', '1st\n2nd\n', ), ] for case in cases: with self.subTest(case.name): source_constructor = _SourceConstructor(case.value) expectation = multi_obj_assertions.ExpectationOnUnFrozenAndFrozen.equals( ''.join(source_constructor.contents), may_depend_on_external_resources=asrt.equals(False), frozen_may_depend_on_external_resources=asrt.equals(False), ) assertion = multi_obj_assertions.assertion_of_sequence_permutations( expectation) # ACT & ASSERT # assertion.apply_without_message( self, multi_obj_assertions.SourceConstructors.of_common( source_constructor), )
def runTest(self): # ARRANGE # may_depend_on_external_resources = False contents = 'the contents' expectation = sut.ExpectationOnUnFrozenAndFrozen.equals( contents, may_depend_on_external_resources=asrt.equals( may_depend_on_external_resources), frozen_may_depend_on_external_resources=asrt.equals( may_depend_on_external_resources), ) data__before_and_after_freeze = StringSourceData( contents, may_depend_on_external_resources) source_constructor = ConstructorOfStringSourceData( data__before_and_after_freeze, data__before_and_after_freeze, ) for checker_variant in check_variants(expectation): with self.subTest(checker_variant.name): # ACT & ASSERT # checker_variant.value.apply( self, sut.SourceConstructors.of_common(source_constructor), asrt.MessageBuilder(), )
def equals_single_line_source_location_path(expected: Line) -> ValueAssertion[SourceLocationPath]: return matches_source_location_path( source_location=matches_source_location( source=matches_line_sequence( first_line_number=asrt.equals(expected.line_number), lines=asrt.matches_sequence([asrt.equals(expected.text)])), file_path_rel_referrer=asrt.is_none), file_inclusion_chain=equals_source_location_sequence([]))
def test_long_path_to_symbol_that_fails(self): # ARRANGE # restrictions_that_should_not_be_used = sut.ReferenceRestrictionsOnDirectAndIndirect( direct=ValueRestrictionThatRaisesErrorIfApplied(), indirect=ValueRestrictionThatRaisesErrorIfApplied()) satisfied_value_type = DataValueType.STRING dissatisfied_value_type = DataValueType.PATH level_3_symbol = symbol_table_entry('level_3_symbol', references=[], value_type=dissatisfied_value_type) level_2_symbol = symbol_table_entry('level_2_symbol', references=[reference_to(level_3_symbol, restrictions_that_should_not_be_used)], value_type=satisfied_value_type) level_1a_symbol = symbol_table_entry('level_1a_symbol', references=[], value_type=satisfied_value_type) level_1b_symbol = symbol_table_entry('level_1b_symbol', references=[reference_to(level_2_symbol, restrictions_that_should_not_be_used)], value_type=satisfied_value_type) level_0_symbol = symbol_table_entry('level_0_symbol', references=[reference_to(level_1a_symbol, restrictions_that_should_not_be_used), reference_to(level_1b_symbol, restrictions_that_should_not_be_used)], value_type=satisfied_value_type) symbol_table_entries = [level_0_symbol, level_1a_symbol, level_1b_symbol, level_2_symbol, level_3_symbol] symbol_table = symbol_tables.symbol_table_from_entries(symbol_table_entries) restriction_on_every_indirect = RestrictionThatRegistersProcessedSymbols( resolver_container_2_result__fun=dissatisfaction_if_value_type_is( DATA_TYPE_2_VALUE_TYPE[dissatisfied_value_type])) restrictions_to_test = sut.ReferenceRestrictionsOnDirectAndIndirect( indirect=restriction_on_every_indirect, direct=unconditionally_satisfied_value_restriction(), meaning_of_failure_of_indirect_reference='meaning of failure') # ACT # actual_result = restrictions_to_test.is_satisfied_by(symbol_table, level_0_symbol.key, level_0_symbol.value) # ASSERT # expected_result = is_failure_of_indirect_reference(failing_symbol=asrt.equals(level_3_symbol.key), path_to_failing_symbol=asrt.equals([level_1b_symbol.key, level_2_symbol.key]), meaning_of_failure=asrt.equals('meaning of failure')) expected_result.apply_with_message(self, actual_result, 'result of processing') actual_processed_symbols = dict(restriction_on_every_indirect.visited.items()) expected_processed_symbol = { level_1a_symbol.key: 1, level_1b_symbol.key: 1, level_2_symbol.key: 1, level_3_symbol.key: 1, } self.assertEqual(expected_processed_symbol, actual_processed_symbols)
def path_relativity_variants_equals(expected: PathRelativityVariants) -> ValueAssertion: return asrt.is_instance_with(PathRelativityVariants, asrt.And([ asrt.sub_component('rel_option_types', PathRelativityVariants.rel_option_types.fget, asrt.equals(expected.rel_option_types)), asrt.sub_component('absolute', PathRelativityVariants.absolute.fget, asrt.equals(expected.absolute)), ]))
def equals_line(expected: Line) -> ValueAssertion[Any]: return asrt.is_instance_with(Line, asrt.And([ asrt.sub_component('line_number', Line.line_number.fget, asrt.equals(expected.line_number)), asrt.sub_component('text', Line.text.fget, asrt.equals(expected.text)) ]))
def equals_name(name: Name) -> ValueAssertion: return asrt.is_instance_with(Name, asrt.and_([ asrt.sub_component('singular', Name.singular.fget, asrt.equals(name.singular)), asrt.sub_component('plural', Name.plural.fget, asrt.equals(name.plural)), ]))
def test_symbol_references(self): file_to_interpret = fs.File('python-program.py', python_program_that_exits_with_code_given_as_first_cl_arg) file_to_interpret_symbol = NameAndValue('file_to_interpret_symbol', file_to_interpret.file_name) python_interpreter_symbol = NameAndValue('python_interpreter_symbol', sys.executable) exit_code_symbol = NameAndValue('exit_code_symbol', 72) argument = ' {python_interpreter} {interpret_option} {file_to_interpret} "{exit_code}"'.format( python_interpreter=symbol_reference_syntax_for_name(python_interpreter_symbol.name), interpret_option=args.option(syntax_elements.EXISTING_FILE_OPTION_NAME).as_str, file_to_interpret=symbol_reference_syntax_for_name(file_to_interpret_symbol.name), exit_code=symbol_reference_syntax_for_name(str(exit_code_symbol.name)), ) following_line = 'following line' source = remaining_source(argument, [following_line]) arrangement = ArrangementWithSds( home_or_sds_contents=HomeOrSdsPopulatorForRelOptionType( parse_file_ref.ALL_REL_OPTIONS_CONFIG.options.default_option, fs.DirContents([file_to_interpret])), symbols=SymbolTable({ python_interpreter_symbol.name: su.string_constant_container(python_interpreter_symbol.value), file_to_interpret_symbol.name: su.string_constant_container(file_to_interpret_symbol.value), exit_code_symbol.name: su.string_constant_container(str(exit_code_symbol.value)), }), ) expectation = embryo_check.Expectation( source=assert_source(current_line_number=asrt.equals(2), column_index=asrt.equals(0)), symbol_usages=asrt.matches_sequence([ matches_reference_2( python_interpreter_symbol.name, equals_data_type_reference_restrictions( parse_file_ref.path_or_string_reference_restrictions( syntax_elements.REL_OPTION_ARG_CONF.options.accepted_relativity_variants ))), matches_reference_2( file_to_interpret_symbol.name, equals_data_type_reference_restrictions( parse_file_ref.path_or_string_reference_restrictions( parse_file_ref.ALL_REL_OPTIONS_CONFIG.options.accepted_relativity_variants ))), matches_reference_2( exit_code_symbol.name, equals_data_type_reference_restrictions(is_any_data_type() )), ]), main_result=spr_check.is_success_result(exit_code_symbol.value, ''), ) parser = sut.embryo_parser('instruction-name') embryo_check.check(self, parser, source, arrangement, expectation)
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 _matches_recording_of(cwd_dir_abs_path: Path, string: str, file_path_rel_referrer: Path) -> ValueAssertion[Recording]: return matches_recording( string=asrt.equals(string), file_location_info=matches_file_location_info( abs_path_of_dir_containing_first_file_path=asrt.equals(cwd_dir_abs_path), file_path_rel_referrer=asrt.equals(file_path_rel_referrer), file_inclusion_chain=asrt.is_empty_sequence, ), )
def is_xpass(sds: ValueAssertion[Optional[SandboxDirectoryStructure]] = asrt.is_instance(SandboxDirectoryStructure), action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] = asrt.is_instance(ActionToCheckOutcome) ) -> ValueAssertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.XPASS), failure_info=asrt.is_none, has_sds=asrt.equals(True), sds=sds, has_action_to_check_outcome=asrt.equals(True), action_to_check_outcome=action_to_check_outcome)
def equals_test_case_reference(expected: TestCaseFileReference) -> ValueAssertion[TestCaseFileReference]: return asrt.and_([ asrt.sub_component('file_path', TestCaseFileReference.file_path.fget, asrt.equals(expected.file_path) ), asrt.sub_component('file_reference_relativity_root_dir', TestCaseFileReference.file_reference_relativity_root_dir.fget, asrt.equals(expected.file_reference_relativity_root_dir) ), ])
def equals_shell_command_driver(expected: CommandDriverForShell) -> ValueAssertion[CommandDriver]: return asrt.is_instance_with_many(CommandDriverForShell, [ asrt.sub_component('shell_command_line', CommandDriverForShell.shell_command_line.fget, asrt.equals(expected.shell_command_line) ), asrt.sub_component('shell', _get_is_shell, asrt.equals(True) ), ])
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 test_definition_in_suite_and_case(self): # ARRANGE # symbol_in_suite = 'SUITE_STRING_SYMBOL' symbol_in_case__before_preproc = 'CASE_STRING_SYMBOL__BEFORE_PRE_PROC' symbol_in_case__after_preproc = 'CASE_STRING_SYMBOL' suite_with_preprocessor = File( 'with-preprocessor.suite', lines_content([ section_names.CONFIGURATION.syntax, suite_instructions.set_search_replace_preprocessor( symbol_in_case__before_preproc, symbol_in_case__after_preproc ), phase_names.SETUP.syntax, sym_def.define_string(symbol_in_suite, 'suite-value'), ]) ) case_with_single_def = File( 'test.case', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(symbol_in_case__before_preproc, 'case-value'), ])) # ACT & ASSERT # test_with_files_in_tmp_dir.check( self, command_line_arguments= symbol_args.explicit_suite_and_case(suite_with_preprocessor.name, case_with_single_def.name), arrangement= Arrangement( cwd_contents=DirContents([ suite_with_preprocessor, case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation= asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=asrt.equals(output.list_of([ output.SymbolReport(symbol_in_suite, ValueType.STRING, num_refs=0), output.SymbolReport(symbol_in_case__after_preproc, ValueType.STRING, num_refs=0), ])), ) )
def test_set_value_SHOULD_be_able_to_have_symbol_references_in_the_right_hand_side(self): variable_name = 'variable_to_assign' my_symbol = NameAndValue('my_symbol', 'my symbol value') your_symbol = NameAndValue('your_symbol', 'your symbol value') value_template = 'pre {MY_SYMBOL} {YOUR_SYMBOL} post' expected_evaluated_value_string = value_template.format( MY_SYMBOL=my_symbol.value, YOUR_SYMBOL=your_symbol.value, ) expected_environ_after_main = { variable_name: expected_evaluated_value_string, } value_source_string = value_template.format( MY_SYMBOL=symbol_reference_syntax_for_name(my_symbol.name), YOUR_SYMBOL=symbol_reference_syntax_for_name(your_symbol.name), ) source_line = ' {variable_name} = {soft_quote}{source_value_string}{soft_quote}'.format( variable_name=variable_name, source_value_string=value_source_string, soft_quote=SOFT_QUOTE_CHAR, ) following_line = 'following line' source = remaining_source(source_line, [following_line]) arrangement = ArrangementWithSds( symbols=SymbolTable({ my_symbol.name: su.string_constant_container(my_symbol.value), your_symbol.name: su.string_constant_container(your_symbol.value), }), ) expectation = embryo_check.Expectation( main_side_effect_on_environment_variables=asrt.equals(expected_environ_after_main), symbol_usages=asrt.matches_sequence([ matches_reference_2( my_symbol.name, is_any_data_type_reference_restrictions()), matches_reference_2( your_symbol.name, is_any_data_type_reference_restrictions()), ]), source=assert_source(current_line_number=asrt.equals(2), column_index=asrt.equals(0)), ) parser = sut.EmbryoParser() embryo_check.check(self, parser, source, arrangement, expectation)
def equals_executable_file_command_driver(expected: CommandDriverForExecutableFile ) -> ValueAssertion[CommandDriver]: return asrt.is_instance_with_many(CommandDriverForExecutableFile, [ asrt.sub_component('executable_file', CommandDriverForExecutableFile.executable_file.fget, asrt.equals(expected.executable_file) ), asrt.sub_component('shell', _get_is_shell, asrt.equals(False) ), ])
def equals_system_program_command_driver(expected: CommandDriverForSystemProgram ) -> ValueAssertion[CommandDriver]: return asrt.is_instance_with_many(CommandDriverForSystemProgram, [ asrt.sub_component('executable_file', CommandDriverForSystemProgram.program.fget, asrt.equals(expected.program) ), asrt.sub_component('shell', _get_is_shell, asrt.equals(False) ), ])