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 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 test_executable_file_must_exist(self): act_phase_instructions = [instr(['non-existing-executable'])] arrangement = arrangement_w_tcds() expectation = Expectation( validation=ValidationExpectationSvh.fails__pre_sds()) check_execution(self, sut.actor(), act_phase_instructions, arrangement, expectation)
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_symbol_reference_on_command_line_SHOULD_be_reported_and_used_in_execution( self): symbol = StringConstantSymbolContext('symbol_name', 'symbol value') string_to_print_template = 'constant and {symbol}' expected_output_template = string_to_print_template + '\n' shell_source_line = shell_commands.command_that_prints_to_stdout( string_to_print_template.format( symbol=symbol.name__sym_ref_syntax)) act_phase_instructions = [ instr([shell_command_source_line_for(shell_source_line)]) ] check_execution( self, sut.actor(), act_phase_instructions, arrangement_w_tcds(symbol_table=symbol.symbol_table), Expectation(symbol_usages=asrt.matches_singleton_sequence( symbol.reference_assertion__w_str_rendering), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=pr.stdout( asrt.equals( expected_output_template.format( symbol=symbol.str_value))))), )
def test_possibility_to_have_sds_path_references_in_argument(self): file_name_of_referenced_file = 'file-name.txt' symbol = ConstantSuffixPathDdvSymbolContext( 'symbol_name', RelOptionType.REL_TMP, file_name_of_referenced_file) executable = 'the-executable' command_line = '{executable} {symbol}'.format( executable=executable, 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, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) ])), symbol_table=symbol.symbol_table) expectation = Expectation( execute=eh_assertions.is_exit_code(0), symbol_usages=asrt.matches_singleton_sequence( symbol.reference_assertion__w_str_rendering), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=pr.stdout( str_asrt.contains(file_name_of_referenced_file))), ) check_execution(self, sut.actor(), [instr([command_line])], arrangement, expectation)
def parse(self, instructions: Sequence[ActPhaseInstruction]) -> ActionToCheck: source_code_lines = all_source_code_lines__std_syntax(instructions) if not source_code_lines: return null.actor().parse(instructions) else: return actor.actor().parse(instructions)
def __init__(self, method_name): super().__init__(method_name) self.constructor = sut.actor() self.hds = fake_hds() self.pre_sds_env = InstructionEnvironmentPreSdsBuilder( self.hds, environ=dict(os.environ), ).build
def _check_with_exit_code(self, exit_code: int): # ARRANGE # result = SubProcessResult( exitcode=exit_code, stdout='output on stdout', stderr='output on stderr', ) command_py_program = py_program.program_that_prints_and_exits_with_exit_code(result) py_file = fs.File( 'the-program.py', command_py_program, ) program_wo_transformation = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdvs.interpret_py_source_file_that_must_exist( path_sdvs.of_rel_option_with_const_file_name( RelOptionType.REL_HDS_CASE, py_file.name, ) ) ) source = args.program( args.symbol_ref_command_line(program_wo_transformation.name), transformation=TO_UPPER_CASE_TRANSFORMER.name__sym_ref_syntax) symbols = [ program_wo_transformation, TO_UPPER_CASE_TRANSFORMER, ] # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr(source.as_arguments.lines)], arrangement_w_tcds( symbol_table=SymbolContext.symbol_table_of_contexts(symbols), hds_contents=hds_populators.contents_in( RelHdsOptionType.REL_HDS_CASE, DirContents([py_file]), ) ), Expectation( symbol_usages=SymbolContext.references_assertion_of_contexts(symbols), execute=asrt_eh.is_exit_code(result.exitcode), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=asrt_proc_result.matches_proc_result( exit_code=asrt.equals(result.exitcode), stdout=asrt.equals(result.stdout.upper()), stderr=asrt.equals(result.stderr), ) ) ), )
def runTest(self): # ARRANGE # command_py_program = py_program.exit_with_code(0) py_file = fs.File( 'the-program.py', lines_content(command_py_program), ) program_wo_transformation = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdvs.interpret_py_source_file_that_must_exist( path_sdvs.of_rel_option_with_const_file_name( RelOptionType.REL_HDS_CASE, py_file.name, ) ) ) error_message = 'error message from transformer' transformer = StringTransformerPrimitiveSymbolContext( 'HARD_ERROR_TRANSFORMER', string_transformers.model_access_raises_hard_error(error_message), ) source = args.program( args.symbol_ref_command_line(program_wo_transformation.name), transformation=transformer.name__sym_ref_syntax) symbols = [ program_wo_transformation, transformer, ] # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr(source.as_arguments.lines)], arrangement_w_tcds( symbol_table=SymbolContext.symbol_table_of_contexts(symbols), hds_contents=hds_populators.contents_in( RelHdsOptionType.REL_HDS_CASE, DirContents([py_file]), ) ), Expectation( symbol_usages=SymbolContext.references_assertion_of_contexts(symbols), execute=asrt_eh.matches_hard_error( asrt_failure_details.is_failure_message_matching__td( asrt_text_doc.is_string_for_test_that_equals(error_message) ) ), ), )
def test_executable_file_must_be_executable(self): executable_file_name = 'existing-executable' act_phase_instructions = [instr([executable_file_name])] arrangement = arrangement_w_tcds( hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([File.empty(executable_file_name)]))) expectation = Expectation( validation=ValidationExpectationSvh.fails__pre_sds()) check_execution(self, sut.actor(), act_phase_instructions, arrangement, expectation)
def runTest(self): # ARRANGE # program_line = args.system_program_command_line( 'non-existing-system-program').as_str # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr([program_line])], arrangement_w_tcds(), Expectation.hard_error_from_execute(), )
def runTest(self): # ARRANGE # symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdvs.system_program( string_sdvs.str_constant('non-existing-system-program'))) program_line = args.symbol_ref_command_line(symbol.name).as_str # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [instr([program_line])], arrangement_w_tcds(symbol_table=symbol.symbol_table), Expectation.hard_error_from_execute( symbol_usages=symbol.usages_assertion), )
def test_multiple_symbol_references_in_executable(self): sub_dir_of_home = 'sub-dir' dir_symbol = ConstantSuffixPathDdvSymbolContext( 'dir_symbol_name', RelOptionType.REL_HDS_ACT, sub_dir_of_home, PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN) executable_file_name_symbol = StringConstantSymbolContext( 'executable_file_name_symbol_name', 'the-executable-file') argument = 'argument_string' expected_output = lines_content([argument]) command_line = '{dir}/{file_name} {argument} '.format( dir=dir_symbol.name__sym_ref_syntax, file_name=executable_file_name_symbol.name__sym_ref_syntax, argument=argument, ) executable_file = fs.python_executable_file( executable_file_name_symbol.str_value, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) arrangement = arrangement_w_tcds( hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([fs.Dir(sub_dir_of_home, [executable_file])])), symbol_table=SymbolContext.symbol_table_of_contexts([ dir_symbol, executable_file_name_symbol, ])) expectation = Expectation( symbol_usages=asrt.matches_sequence([ dir_symbol.reference_assertion__path_or_string, executable_file_name_symbol. reference_assertion__string__w_all_indirect_refs_are_strings, ]), 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 runTest(self): # ARRANGE # source_w_relative_name_of_existing_file = args.interpret_py_source_file( 'program.py') # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [ instr( source_w_relative_name_of_existing_file.as_arguments.lines) ], arrangement_w_tcds(), Expectation(validation=ValidationExpectationSvh.fails__pre_sds()), )
def test_string_symbol_reference_in_executable_and_argument(self): symbol_for_executable = StringConstantSymbolContext( 'executable_symbol_name', 'the-executable') argument_symbol = StringConstantSymbolContext('argument_symbol_name', 'string-constant') expected_output = lines_content([argument_symbol.str_value]) command_line = '{executable} {argument} '.format( executable=symbol_for_executable.name__sym_ref_syntax, argument=argument_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( symbol_for_executable.str_value, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) ])), symbol_table=SymbolContext.symbol_table_of_contexts([ symbol_for_executable, argument_symbol, ])) expectation = Expectation( execute=eh_assertions.is_exit_code(0), symbol_usages=asrt.matches_sequence([ symbol_for_executable.reference_assertion__path_or_string( PATH_RELATIVITY_VARIANTS_FOR_FILE_TO_RUN), argument_symbol.reference_assertion__w_str_rendering, ]), 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 runTest(self): for case in VALIDATION_CASES: with self.subTest(case.name): program_sdv = program_sdvs.ref_to_exe_file( path_sdvs.of_rel_option_with_const_file_name( case.path_relativity, 'non-existing')) program_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdv) integration_check.check_execution( self, sut.actor(), [ instr([ args.symbol_ref_command_line( program_symbol.name).as_str ]) ], arrangement_w_tcds( symbol_table=program_symbol.symbol_table, ), Expectation(symbol_usages=program_symbol.usages_assertion, validation=case.expectation), )
def runTest(self): # ARRANGE # result = SubProcessResult( exitcode=5, stdout='output on stdout from existing py program file', stderr='output on stderr from existing py program file', ) py_file = fs.File( 'the-program.py', py_program.program_that_prints_and_exits_with_exit_code(result), ) source_w_relative_name_of_existing_file = args.interpret_py_source_file( py_file.name) # ACT & ASSERT # integration_check.check_execution( self, sut.actor(), [ instr( source_w_relative_name_of_existing_file.as_arguments.lines) ], arrangement_w_tcds( hds_contents=relativity_configurations.PROGRAM_FILE. populator_for_relativity_option_root__hds( DirContents([py_file]))), Expectation(execute=asrt_eh.is_exit_code(result.exitcode), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=asrt_proc_result. matches_proc_result( exit_code=asrt.equals(result.exitcode), stdout=asrt.equals(result.stdout), stderr=asrt.equals(result.stderr), ))), )
def runTest(self): actor = sut.actor() act_phase_instructions = [ instr(['system-under-test first-argument "quoted argument"']) ] arrangement = arrangement_w_tcds( hds_contents=relativity_configurations.ATC_FILE. populator_for_relativity_option_root__hds( fs.DirContents([ fs.python_executable_file( 'system-under-test', PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) ]))) expected_output = lines_content(['first-argument', 'quoted argument']) expectation = Expectation( 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, actor, act_phase_instructions, arrangement, expectation)
def test_symbol_reference_in_arguments(self): list_symbol = ListConstantSymbolContext( 'list_symbol_name', ['first element', 'second element']) string_constant = 'string-constant' expected_output = lines_content(['string-constant'] + list_symbol.constant_list) executable = 'the-executable' command_line = '{executable} {string_constant} {list_symbol}'.format( executable=executable, string_constant=string_constant, list_symbol=list_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, PYTHON_PROGRAM_THAT_PRINTS_COMMAND_LINE_ARGUMENTS_ON_SEPARATE_LINES ) ])), symbol_table=list_symbol.symbol_table) expectation = Expectation( symbol_usages=asrt.matches_singleton_sequence( list_symbol.reference_assertion), 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 runTest(self): # ARRANGE # exit_code_from_program = 0 py_file = fs.File( 'the-program', lines_content(py_program.exit_with_code(exit_code_from_program)), ) program_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL', program_sdvs.interpret_py_source_file_that_must_exist( path_sdvs.of_rel_option_with_const_file_name( RelOptionType.REL_HDS_CASE, py_file.name, ))) program_line = args.symbol_ref_command_line(program_symbol.name).as_str with tmp_dir_in_path_with_files(DirContents([py_file])) 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), hds_contents=hds_populators.contents_in( RelHdsOptionType.REL_HDS_CASE, DirContents([py_file])), ), Expectation( symbol_usages=program_symbol.usages_assertion, execute=asrt_eh.is_exit_code( exit_code_from_program)), )
def _parse_command_line_actor( token_parser: TokenParser) -> NameAndValue[Actor]: return NameAndValue(actors.COMMAND_LINE_ACTOR.singular_name, program_actor.actor())
def command_line_actor_setup() -> ActPhaseSetup: return ActPhaseSetup(actors.COMMAND_LINE_ACTOR.singular_name, command_line_actor.actor())
def __init__(self): super().__init__(sut.actor())
stdin_defined_for_program=[ ss_sdvs.const_str(stdin_defined_by_the_program) ]) full_stdin = stdin_defined_by_the_program + stdin_from_act_exe_input # ACT & ASSERT # CHECKER.check__abs_stx( self, test_setup.program_that_copies_stdin_syntax(), Arrangement( symbols=SymbolContext.symbol_table_of_contexts( test_setup.symbols), atc_exe_input=AtcExeInputArr( stdin_contents=stdin_from_act_exe_input, ), tcds=TcdsArrangementPreAct(), ), Expectation( symbol_usages=SymbolContext.usages_assertion_of_contexts( test_setup.symbols), post_sds=PostSdsExpectation.constant( sub_process_result_from_execute=asrt_proc_result. matches_proc_result(exit_code=asrt.equals(0), stdout=asrt.equals(full_stdin))), ), ) CHECKER = integration_check.Checker(actor.actor()) if __name__ == '__main__': unittest.TextTestRunner().run(suite())