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 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_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 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_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_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_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_file(self): emtpy_test_case_file = File.empty('empty.xly') check_case_and_suite( self, symbol_command_arguments=[emtpy_test_case_file.name], arrangement=Arrangement(cwd_contents=DirContents([ emtpy_test_case_file, ])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_OK))
def test_superfluous_arguments(self): case_file = File.empty('test.xly') check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_file.name, 'symbol_name', ) + ['superfluous'], arrangement=Arrangement(cwd_contents=DirContents([case_file])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_INVALID_USAGE))
def test_invalid_symbol_name(self): case_file = File.empty('test.xly') check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_file.name, NOT_A_VALID_SYMBOL_NAME, ), arrangement=Arrangement(cwd_contents=DirContents([case_file])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_INVALID_USAGE))
def test_invalid_option(self): case_file = File.empty('test.xly') check_case_and_suite( self, symbol_command_arguments=[ case_file.name, 'symbol_name', short_and_long_option_syntax.long_syntax('invalid'), ], arrangement=Arrangement(cwd_contents=DirContents([case_file])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_INVALID_USAGE))
def test_superfluous_symbol_name(self): case_file = File.empty('test.case') check_case_and_suite( self, symbol_command_arguments=[ case_file.name, 'symbol_name', 'superfluous', ], arrangement=Arrangement(cwd_contents=DirContents([case_file])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_INVALID_USAGE))
def test_invalid_syntax(self): file_with_invalid_syntax = File( 'invalid-syntax.xly', lines_content([ SectionName('nonExistingSection').syntax, ])) check_case_and_suite( self, [file_with_invalid_syntax.name], Arrangement(cwd_contents=DirContents([ file_with_invalid_syntax, ])), asrt_proc_result.is_result_for_empty_stdout( exit_values.NO_EXECUTION__SYNTAX_ERROR.exit_code))
def test_multiple_definition(self): setup_symbol_name = 'SETUP_SYMBOL' before_assert_symbol_name = 'BEFORE_ASSERT_SYMBOL' assert_symbol_name = 'ASSERT_SYMBOL' cleanup_symbol_name = 'CLEANUP_SYMBOL' case_with_one_def_per_phase = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(setup_symbol_name, setup_symbol_name + 'value'), phase_names.BEFORE_ASSERT.syntax, sym_def.define_string(before_assert_symbol_name, before_assert_symbol_name + 'value'), phase_names.ASSERT.syntax, sym_def.define_string(assert_symbol_name, assert_symbol_name + 'value'), phase_names.CLEANUP.syntax, sym_def.define_string(cleanup_symbol_name, cleanup_symbol_name + 'value'), ])) check_case_and_suite( self, symbol_command_arguments=[case_with_one_def_per_phase.name], arrangement=Arrangement( cwd_contents=DirContents([ case_with_one_def_per_phase, ]), 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(setup_symbol_name, ValueType.STRING, num_refs=0), output.SymbolSummary(before_assert_symbol_name, ValueType.STRING, num_refs=0), output.SymbolSummary(assert_symbol_name, ValueType.STRING, num_refs=0), output.SymbolSummary(cleanup_symbol_name, ValueType.STRING, num_refs=0), ])), ))
def test_invalid_arguments(self): # ARRANGE # file_name = 'file.xly' cases = [ NameAndValue('file-arg is missing', []), NameAndValue('file-arg is not existing', [file_name]), ] for case in cases: with self.subTest(case.name): cli_arguments = case.value # ACT & ASSERT # check_case_and_suite( self, cli_arguments, arrangement=Arrangement(), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_codes.EXIT_INVALID_USAGE))
def test_invalid_symbol_reference(self): file_with_invalid_case = File( 'invalid-symbol-reference.xly', lines_content([ phase_names.SETUP.syntax, sym_def.reference_to('UNDEFINED_SYMBOL', ValueType.STRING), ])) check_case_and_suite( self, symbol_command_arguments=[file_with_invalid_case.name], arrangement=Arrangement( main_program_config=sym_def.main_program_config(), cwd_contents=DirContents([ file_with_invalid_case, ])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_values.EXECUTION__VALIDATION_ERROR.exit_code))
def test_invalid_syntax_of_act_phase(self): file_with_invalid_syntax = File( 'invalid-syntax.xly', lines_content([ phase_names.ACT.syntax, 'invalid contents', ])) check_case_and_suite( self, symbol_command_arguments=[file_with_invalid_syntax.name], arrangement=Arrangement( main_program_config=sym_def.main_program_config( ActorThatRaisesParseException()), cwd_contents=DirContents([ file_with_invalid_syntax, ])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_values.EXECUTION__SYNTAX_ERROR.exit_code))
def test_hard_error_from_instruction_in_conf_phase(self): file_with_failing_conf_phase_instruction = File( 'hard-error.xly', lines_content([ phase_names.CONFIGURATION.syntax, sym_def.UNCONDITIONALLY_HARD_ERROR_CONF_PHASE_INSTRUCTION_NAME, ])) check_case_and_suite( self, symbol_command_arguments=[ file_with_failing_conf_phase_instruction.name ], arrangement=Arrangement( main_program_config=sym_def.main_program_config(), cwd_contents=DirContents([ file_with_failing_conf_phase_instruction, ])), expectation=asrt_proc_result.is_result_for_empty_stdout( exit_values.EXECUTION__HARD_ERROR.exit_code))
def test_single_reference_to_builtin_symbol(self): name_of_user_defined_symbol = 'USER_DEFINED_SYMBOL' builtin_symbol = StringSymbolContext.of_constant( 'BUILTIN_SYMBOL', 'builtin string symbol value') definition_source = sym_def.define_string( name_of_user_defined_symbol, symbol_reference_syntax_for_name(builtin_symbol.name)) case_with_single_def = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, definition_source, ])) expected_reference_output = output.Reference( phase_identifier.SETUP, output.LineInFilePosition(case_with_single_def.name, 2), [ definition_source, ]) check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_with_single_def.name, 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(builtin_symbol), ]), ), 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_symbol_with_reference_to_builtin_symbol(self): existing_builtin_symbol = StringSymbolContext.of_constant( 'BUILTIN_STRING_SYMBOL', 'the builtin symbol value') name_of_existing_user_defined_symbol = 'USER_DEFINED_STRING_SYMBOL' case_with_single_def = File( 'test.case', lines_content([ phase_names.SETUP.syntax, sym_def.define_string( name_of_existing_user_defined_symbol, symbol_reference_syntax_for_name( existing_builtin_symbol.name)), ])) expected_first_line = output.summary_of_single( output.SymbolSummary(name_of_existing_user_defined_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_user_defined_symbol, ), 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=asrt_str.first_line(asrt.equals(expected_first_line))))
def test_references_SHOULD_be_listed_phase_order(self): name_of_existing_symbol = 'STRING_SYMBOL' reference_source = sym_def.reference_to(name_of_existing_symbol, ValueType.STRING) case_with_references = File( 'test.xly', lines_content([ phase_names.SETUP.syntax, sym_def.define_string(name_of_existing_symbol, 'value'), phase_names.CLEANUP.syntax, reference_source, phase_names.ASSERT.syntax, reference_source, phase_names.BEFORE_ASSERT.syntax, reference_source, phase_names.ACT.syntax, reference_source, phase_names.SETUP.syntax, reference_source, ])) expected_reference_outputs = [ output.Reference( phase_identifier.SETUP, output.LineInFilePosition(case_with_references.name, 12), [reference_source]), output.Reference(phase_identifier.ACT, None, [reference_source]), output.Reference( phase_identifier.BEFORE_ASSERT, output.LineInFilePosition(case_with_references.name, 8), [reference_source]), output.Reference( phase_identifier.ASSERT, output.LineInFilePosition(case_with_references.name, 6), [reference_source]), output.Reference( phase_identifier.CLEANUP, output.LineInFilePosition(case_with_references.name, 4), [reference_source]), ] expected_output_lines = list( itertools.chain.from_iterable( intersperse_list(['', ''], list( map(output.Reference.output_lines, expected_reference_outputs))))) check_case_and_suite( self, symbol_command_arguments=symbol_args.individual__references( case_with_references.name, name_of_existing_symbol, ), arrangement=Arrangement( cwd_contents=DirContents([ case_with_references, ]), 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_output_lines))))