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 test_empty_blocks_SHOULD_BE_separated_by_single_block_separator(self): # Have not implemented filtering of non-empty blocks. # Reason is that such blocks should not be constructed. # But implement it if it appears to be useful for making # construction easier. # ARRANGE # string_1 = 'the 1st string' empty_block = s.MajorBlock([ s.MinorBlock( [], s.ELEMENT_PROPERTIES__NEUTRAL, ), ], s.ELEMENT_PROPERTIES__NEUTRAL) non_empty_block = s.MajorBlock( [ single_line_minor_block_w_plain_properties(string_1), ], s.ELEMENT_PROPERTIES__NEUTRAL, ) cases = [ NEA( 'two empty blocks', lines_content([ MAJOR_BLOCKS_SEPARATOR, ]), [ empty_block, empty_block, ], ), NEA( 'first non-empty, second empty', lines_content([ string_1, MAJOR_BLOCKS_SEPARATOR, ]), [ non_empty_block, empty_block, ], ), NEA( 'first non-empty, second empty', lines_content([ string_1, MAJOR_BLOCKS_SEPARATOR, ]), [ non_empty_block, empty_block, ], ), ] for case in cases: check_block_sequence_and_document(self, case)
def file_structure(self, root_path: pathlib.Path) -> DirContents: return DirContents([ File('main.suite', lines_content(['[cases]', 'the.case'])), File( 'the.case', lines_content([ '[act]', 'system-under-test', '[assert]', 'exit-code {eq} 0'.format(eq=comparators.EQ.name) ])), python_executable_file('system-under-test', PYTHON_PROGRAM_THAT_EXISTS_WITH_STATUS_0) ])
class ReferencedInclusionDirectiveFileInIncludedFileDoesNotExist( check_exception.Setup): file_1_invalid_inclusion_line = ' '.join( [INCLUDING_DIRECTIVE_INFO.singular_name, 'does-not-exist.txt']) file_1 = File('1.xly', lines_content([file_1_invalid_inclusion_line])) root_suite_inclusion_line = ' '.join( [INCLUDING_DIRECTIVE_INFO.singular_name, file_1.name]) inclusion_line_in_file_1 = single_line_sequence( 1, file_1_invalid_inclusion_line) root_suite_file = File( '0.suite', lines_content([ phase_names.CLEANUP.syntax, root_suite_inclusion_line, ])) inclusion_line_in_root_file = single_line_sequence( 2, root_suite_inclusion_line) expected_source_location_path = SourceLocationPath( SourceLocation( inclusion_line_in_file_1, file_1.name_as_path, ), [ SourceLocation( inclusion_line_in_root_file, root_suite_file.name_as_path, ) ]) def root_suite_based_at(self, root_path: pathlib.Path) -> pathlib.Path: return self.root_suite_file.name_as_path def file_structure_to_read(self) -> DirContents: return DirContents([self.root_suite_file, self.file_1]) def check_exception(self, root_path: pathlib.Path, actual: Exception, put: unittest.TestCase): put.assertIsInstance(actual, SuiteParseError) expectation = matches_suite_parse_error( suite_file=asrt.equals(self.root_suite_based_at(root_path)), maybe_section_name=asrt.equals(phase_names.CLEANUP.plain), source=equals_line_sequence(self.inclusion_line_in_file_1), source_location=equals_source_location_path( self.expected_source_location_path), document_parser_exception=asrt.is_instance( sec_doc_exceptions.FileAccessError), ) expectation.apply(put, actual)
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.SymbolSummary(symbol_in_suite, ValueType.STRING, num_refs=0), output.SymbolSummary(symbol_in_case__after_preproc, ValueType.STRING, num_refs=0), ])), ))
def file_structure(self, root_path: pathlib.Path) -> DirContents: exe_file = python_executable_file('executable-file', PYTHON_PROGRAM_THAT_EXISTS_WITH_STATUS_0) instruction_that_runs_program = '{run} {exe_file}'.format( run=instruction_names.RUN_INSTRUCTION_NAME, exe_file=exe_file.name, ) return DirContents([ File('main.suite', lines_content(['[cases]', 'the.case'])), File('the.case', lines_content(['[setup]', instruction_that_runs_program, ])), exe_file ])
def file_structure(self, root_path: pathlib.Path) -> DirContents: return DirContents([ File('main.suite', lines_content(['[cases]', 'the.case'])), File( 'the.case', lines_content([ '[conf]', '[setup]', '[act]', '[assert]', '[before-assert]', '[cleanup]', ])), ])
def file_structure(self, root_path: pathlib.Path) -> DirContents: return DirContents([ File( 'main.suite', lines_content( ['[suites]', 'sub.suite', '[cases]', 'main.case'])), File('main.case', ''), File( 'sub.suite', lines_content( ['[suites]', 'sub-sub.suite', '[cases]', 'sub.case'])), File('sub.case', ''), File('sub-sub.suite', ''), ])
def file_structure_to_read(self, root_path: pathlib.Path) -> DirContents: return DirContents([ Dir('main-sub-dir', [ File( 'main.suite', lines_content([ section_names.SUITES.syntax, '../super.suite', ])), ]), File('super.suite', lines_content([ 'super.case', ])), File.empty('super.case'), ])
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_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 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_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_indentation_element_properties_SHOULD_be_accumulated(self): # ARRANGE # line_object = s.StringLineObject('the string') block_properties = ElementProperties( Indentation(2, '<block indent suffix>'), TEXT_STYLE__NEUTRAL, ) line_element_properties = ElementProperties( Indentation(3, '<line element indent suffix>'), TEXT_STYLE__NEUTRAL, ) # ACT & ASSERT # check_minor_block( self, to_render=s.MinorBlock( [s.LineElement(line_object, line_element_properties)], block_properties, ), expectation=lines_content([ ((LAYOUT_SETTINGS.minor_block.indent * block_properties.indentation.level) + block_properties.indentation.suffix + (LAYOUT_SETTINGS.line_element_indent * line_element_properties.indentation.level) + line_element_properties.indentation.suffix + line_object.string) ]), )
def file_structure(self, root_path: pathlib.Path) -> DirContents: return DirContents([ File('main.suite', lines_content(['[suites]', '?'])), File.empty('1'), Dir('2', []), File.empty('3'), ])
def runTest(self): lines = ['1', '2', '3'] actual_number_of_lines = len(lines) integer_matcher = IntegerMatcherSymbolContext.of_primitive( 'INTEGER_MATCHER', matchers.matcher( comparators.EQ, actual_number_of_lines, )) integration_check.CHECKER__PARSE_SIMPLE.check( self, args.NumLines( integer_matcher.name__sym_ref_syntax).as_remaining_source, model_constructor.of_str(self, lines_content(lines)), arrangement_w_tcds(symbols=integer_matcher.symbol_table, ), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=integer_matcher.references_assertion, ), ExecutionExpectation( main_result=asrt_matching_result.matches_value(True)), ), )
def test(self): name_of_existing_symbol = 'STRING_SYMBOL' not_the_name_of_an_existing_symbol = 'NON_EXISTING_SYMBOL' case_with_single_def = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(name_of_existing_symbol, 'value'), ])) check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_with_single_def.name, not_the_name_of_an_existing_symbol, ), arrangement=Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config(), ), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_values.EXECUTION__HARD_ERROR.exit_code))
def test_builtin_symbol_with_reference_to_it(self): existing_builtin_symbol = StringSymbolContext.of_constant( 'BUILTIN_STRING_SYMBOL', 'the builtin symbol value') case_with_single_def = File( 'test.case', lines_content([ phase_names.SETUP.syntax, sym_def.reference_to(existing_builtin_symbol.name, existing_builtin_symbol.value.value_type), ])) check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__definition( case_with_single_def.name, existing_builtin_symbol.name, ), arrangement=Arrangement( cwd_contents=DirContents([ case_with_single_def, ]), main_program_config=sym_def.main_program_config( builtin_symbols=[ sym_def.builtin_symbol(existing_builtin_symbol) ], ), ), expectation=asrt_proc_result.sub_process_result( exitcode=asrt.equals(exit_codes.EXIT_OK), stdout=definition_of_builtin_symbol( existing_builtin_symbol.name, existing_builtin_symbol.value.value_type, num_refs=1)))
def runTest(self): # ARRANGE # exit_code_from_program = 0 exe_file_in_path = fs.python_executable_file( 'the-program', lines_content(py_program.exit_with_code(exit_code_from_program)), ) program_symbol = StringConstantSymbolContext( 'PROGRAM_NAME_SYMBOL', exe_file_in_path.name, ) program_line = args.system_program_command_line( program_symbol.name__sym_ref_syntax).as_str with tmp_dir_in_path_with_files(DirContents([exe_file_in_path ])) as environ: for source_case in valid_source_variants(program_line): with self.subTest(source_case.name): # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr([program_line])], arrangement_w_tcds( symbol_table=program_symbol.symbol_table, act_exe_input=AtcExeInputArr(environ=environ), ), Expectation( symbol_usages=asrt.matches_singleton_sequence( program_symbol. reference_assertion__string__w_all_indirect_refs_are_strings ), execute=asrt_eh.is_exit_code( exit_code_from_program)), )
def tmp_file_containing_lines(content_lines: Sequence[str], suffix: str = '') -> pathlib.Path: """ Short cut to tmp_file_containing combined with giving the contents as a string of lines. """ return tmp_file_containing(lines_content(content_lines), suffix=suffix)
def test_symbol_without_references(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.summary_of_single( output.SymbolSummary(name_of_existing_symbol, ValueType.STRING, num_refs=0)) check_case_and_suite( self, symbol_command_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 runTest(self): actual_contents = lines_content(['1', '2', '3', '4']) symbol_value = '3' constant_value = '1' operand_symbol = StringSymbolContext.of_constant( 'operand_symbol', symbol_value) expression_that_evaluates_to_actual_number_of_lines = '{sym_ref}+{const}'.format( sym_ref=symbol_reference_syntax_for_name(operand_symbol.name), const=constant_value, ) symbol_table_with_operand_symbol = operand_symbol.symbol_table expected_symbol_usages = asrt.matches_sequence( [is_reference_to_symbol_in_expression(operand_symbol.name)]) self._check_variants_with_expectation_type( InstructionArgumentsVariantConstructor( operator=comparators.GTE.name, operand=expression_that_evaluates_to_actual_number_of_lines), expected_result_of_positive_test=PassOrFail.PASS, actual_file_contents=actual_contents, symbols=symbol_table_with_operand_symbol, expected_symbol_references=expected_symbol_usages, )
def test_escaping_markup_token_inside_literal_block(self): check(self, [sut.LiteralLayout(lines_content(['```']))], sut.parse(['```', '\\```', '```', ]))
def _doTest(self, maybe_not: ExpectationTypeConfigForNoneIsSuccess): expected_content_line_template = 'expected content line, with {symbol} ref' def expected_content(symbol_content: str) -> str: return expected_content_line_template.format(symbol=symbol_content) symbol = StringConstantSymbolContext('symbol_name', 'the symbol value') self._check( test_configuration.source_for( args('{maybe_not} {equals} <<EOF', maybe_not=maybe_not.nothing__if_positive__not_option__if_negative), [expected_content(symbol.name__sym_ref_syntax), 'EOF', 'following line']), model_constructor.of_str(self, lines_content([expected_content(symbol.str_value)])), arrangement_w_tcds( post_population_action=MK_SUB_DIR_OF_ACT_AND_MAKE_IT_CURRENT_DIRECTORY, symbols=symbol.symbol_table), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(3), symbol_references=asrt.matches_sequence([ symbol.reference_assertion__w_str_rendering ]), ), ExecutionExpectation( main_result=maybe_not.pass__if_positive__fail__if_negative, ), ), )
def test_single_literal_block_w_class(self): check(self, [sut.LiteralLayout(lines_content(['literal line']), 'the-class')], sut.parse(['```:the-class', 'literal line', '```', ]))
def file_structure_to_read(self) -> DirContents: return DirContents([ File('main.suite', lines_content([ '"starting but no closing double quote', ])), ])
def test_symbol_value_with_space_SHOULD_be_given_as_single_argument_to_program( self): symbol = StringConstantSymbolContext('symbol_name', 'symbol value with space') expected_output = lines_content([symbol.str_value]) executable_file_name = 'the-executable_file_name' command_line = '{executable_file_name} {symbol}'.format( executable_file_name=executable_file_name, symbol=symbol.name__sym_ref_syntax, ) arrangement = arrangement_w_tcds( hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([ fs.python_executable_file( executable_file_name, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) ])), symbol_table=symbol.symbol_table) expectation = Expectation( symbol_usages=asrt.matches_sequence( [symbol.reference_assertion__w_str_rendering]), execute=eh_assertions.is_exit_code(0), post_sds=PostSdsExpectation. constant(sub_process_result_from_execute=pr.stdout( asrt.Equals(expected_output, 'CLI arguments, one per line'))), ) check_execution(self, sut.actor(), [instr([command_line])], arrangement, expectation)
def test_cwd__should_be__directory_containing_test_case_during_preprocessing_and_then_restored( self): test_case_source = 'CURRENT_WORKING_DIRECTORY' preprocessor_that_search_replace_current_working_directory = lines_content( [ "import os", "print(os.getcwd())", ]) cwd_before = os.getcwd() with test_case_and_preprocessor_source(test_case_source, preprocessor_that_search_replace_current_working_directory) \ as (test_case_path, preprocessor_file_path): pre_proc = PreprocessorViaExternalProgram( py_exe.args_for_interpreting(preprocessor_file_path)) result = pre_proc.apply(test_case_path, test_case_source) cwd_after = os.getcwd() self.assertEqual(cwd_before, cwd_after, 'Current Working Directory should be restored') test_case_dir = test_case_path.parent expected_test_case_contents = str(test_case_dir) + os.linesep self.assertEqual( expected_test_case_contents, result, """Test case source is expected to be the name of the directory that contains the test case.""")
def of_lines(on_separate_lines: Sequence[AbstractSyntax]) -> str: layout_spec = LayoutSpec.of_default() return misc_formatting.lines_content([ syntax.tokenization().layout(layout_spec) for syntax in on_separate_lines ])