def test_file__rel_non_hds(self): accepted_relativity_configurations = [ rel_opt_conf.conf_rel_any(RelOptionType.REL_ACT), rel_opt_conf.conf_rel_any(RelOptionType.REL_TMP), rel_opt_conf.symbol_conf_rel_any( RelOptionType.REL_TMP, 'SYMBOL', RELATIVITY_OPTIONS_CONFIGURATION.options. accepted_relativity_variants), ] stdin_file = File('stdin.txt', 'contents of stdin / rel non-hds') for rel_conf in accepted_relativity_configurations: syntax = InstructionAbsStx( StringSourceOfFileAbsStx( rel_conf.path_abs_stx_of_name(stdin_file.name))) with self.subTest(option_string=rel_conf.option_argument): CHECKER.check_multi_source__abs_stx( self, syntax, Arrangement( tcds_contents=rel_conf. populator_for_relativity_option_root( DirContents([stdin_file])), symbols=rel_conf.symbols.in_arrangement(), ), MultiSourceExpectation( symbols_after_parse=rel_conf.symbols. usages_expectation(), settings_builder=_stdin_is_present_and_valid( stdin_file.contents, may_depend_on_external_resources=True), ), )
def runTest(self): file_in_root = File.empty('file-in-root.txt') files_in_root_dir = [file_in_root] file_matcher_symbol = FileMatcherSymbolContext.of_primitive_constant( 'FILE_MATCHER_SYMBOL', True, ) file_matcher_cases = [ NInpArr( 'wo file matcher', None, (), ), NInpArr( 'w file matcher', file_matcher_symbol.abstract_syntax, [file_matcher_symbol], ), ] relativity_cases = [ rel_opt_conf.conf_rel_any(RelOptionType.REL_TMP), rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE), ] for expectation_type in ExpectationType: for file_matcher_case in file_matcher_cases: for rel_conf in relativity_cases: with self.subTest(relativity=rel_conf.relativity, file_matcher=file_matcher_case.name, expectation_type=expectation_type): CHECKER.check__abs_stx__source_variants( self, InstructionArguments( rel_conf.path_abs_stx_of_name__c([ file_in_root.name, 'path-to-check' ]), expectation_type=expectation_type, file_matcher=file_matcher_case.input, ), ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(file_matcher_case.arrangement), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents(files_in_root_dir) ) ) ), MultiSourceExpectation( symbol_usages=SymbolContext.usages_assertion_of_contexts(file_matcher_case.arrangement), execution=ExecutionExpectation( main_result=pfh_assertions.is_pass_of_fail( expectation_type is ExpectationType.NEGATIVE ) ) ) )
def relativity_options_of_symbol( symbol_name: str ) -> List[RelativityOptionConfigurationForRelOptionType]: return [ rel_opt.default_conf_rel_any(RelOptionType.REL_HDS_CASE), rel_opt.conf_rel_any(RelOptionType.REL_ACT), rel_opt.conf_rel_any(RelOptionType.REL_TMP), rel_opt.symbol_conf_rel_any( RelOptionType.REL_TMP, symbol_name, syntax_elements. EXE_FILE_REL_OPTION_ARG_CONF.options.accepted_relativity_variants), rel_opt.symbol_conf_rel_any( RelOptionType.REL_HDS_CASE, symbol_name, syntax_elements. EXE_FILE_REL_OPTION_ARG_CONF.options.accepted_relativity_variants), ]
def runTest(self): output_to_stderr = 'on stderr' py_file = File( 'exit-with-value-on-command-line.py', py_pgm_that_exits_with_1st_value_on_command_line(output_to_stderr)) py_file_rel_opt_conf = relativity_options.conf_rel_any( RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_that_executes_py_pgm_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_THAT_EXECUTES_PY_FILE', program_sdvs.interpret_py_source_file_that_must_exist( py_file_conf.path_sdv)) symbols = program_that_executes_py_pgm_symbol.symbol_table instruction_arguments = [ pgm_args.symbol_ref_command_line( program_that_executes_py_pgm_symbol.name), 0, ] self.conf.run_test( self, single_line_source(args.sequence(instruction_arguments).as_str), self.conf.arrangement(tcds_contents=py_file_rel_opt_conf. populator_for_relativity_option_root( DirContents([py_file])), symbols=symbols), self.conf.expect_success(symbol_usages=asrt.matches_sequence( [program_that_executes_py_pgm_symbol.reference_assertion])), )
def runTest(self): # ARRANGE # checked_dir = Dir.empty('the-checked-dir') fsm_1 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_1', True) fsm_2 = FilesMatcherSymbolContextOfPrimitiveConstant('fsm_2', False) symbols = [fsm_1, fsm_2] rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_ACT) arguments = args.recursive( rel_conf.path_argument_of_rel_name(checked_dir.name), fsm_args.disjunction([fsm_1.argument, fsm_2.argument]), ) is_pass = fsm_1.result_value or fsm_2.result_value # ACT # & ASSERT # INSTRUCTION_CHECKER.check_2( self, arguments.as_remaining_source, ArrangementPostAct2( symbols=SymbolContext.symbol_table_of_contexts(symbols), tcds=TcdsArrangementPostAct( tcds_contents=rel_conf. populator_for_relativity_option_root( DirContents([checked_dir])))), Expectation2( ParseExpectation( source=asrt_source.source_is_at_end, symbol_usages=SymbolContext.usages_assertion_of_contexts( symbols), ), ExecutionExpectation( main_result=asrt_pfh.is_non_hard_error(is_pass), ), ))
def _check(self, expected_contents: str, actual_contents: str, may_depend_on_external_resources: bool, expected_result: bool, ): expected_file_relativity = rel_opt.conf_rel_any(RelOptionType.REL_HDS_CASE) expected_contents_file = File('expected.txt', expected_contents) integration_check.CHECKER__PARSE_SIMPLE.check( self, args2.Equals.eq_file( expected_file_relativity.path_argument_of_rel_name(expected_contents_file.name) ).as_remaining_source, model_constructor.of_str(self, actual_contents, may_depend_on_external_resources=may_depend_on_external_resources), arrangement_w_tcds( tcds_contents=expected_file_relativity.populator_for_relativity_option_root( DirContents([expected_contents_file]) ) ), Expectation( execution=ExecutionExpectation( main_result=asrt_matching_result.matches_value( expected_result ) ), ), )
def check_parsing_with_different_source_variants( self, make_instruction_arguments: InstructionArgumentsVariantConstructor, default_relativity: RelOptionType, non_default_relativity: RelOptionType, main_result_for_positive_expectation: PassOrFail, contents_of_relativity_option_root: DirContents = empty_dir_contents(), following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): rel_opt_configs = [ rel_opt_conf.default_conf_rel_any(default_relativity), rel_opt_conf.conf_rel_any(non_default_relativity), ] for rel_opt_config in rel_opt_configs: for expectation_type_of_test_case in ExpectationType: etc = pfh_expectation_type_config( expectation_type_of_test_case) instruction_arguments = make_instruction_arguments.apply( etc, rel_opt_config) for source in equivalent_source_variants__with_source_check__consume_last_line( self.put, instruction_arguments): self._check_( source, etc, main_result_for_positive_expectation, rel_opt_config, contents_of_relativity_option_root, following_symbols_setup=following_symbols_setup)
def test_without_transformer(self): # ARRANGE # src_file = fs.File('source-file.txt', 'contents of source file') src_rel_opt_conf = conf_rel_any(RelOptionType.REL_TMP) checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_rel_opt_conf.relativity)) file_contents_abs_stx = string_source_abs_stx.StringSourceOfFileAbsStx( src_rel_opt_conf.path_abs_stx_of_name(src_file.name) ) # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(file_contents_abs_stx), arrangement_w_tcds( tcds_contents=src_rel_opt_conf.populator_for_relativity_option_root( DirContents([src_file])) ), MultiSourceExpectation.of_prim__const( asrt_string_source.pre_post_freeze__matches_str__const( src_file.contents, may_depend_on_external_resources=True, ), symbol_references=asrt.is_empty_sequence, ) )
def environment_exe_case( environment: Dict[str, str], program_symbol_name: str, ) -> NExArr[PrimAndExeExpectation[MatcherWTrace, MatchingResult], Arrangement]: py_file = File( 'environment-vars-check.py', py_programs. pgm_that_exists_with_zero_exit_code_iff_environment_vars_not_included( environment)) py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_symbol = ProgramSymbolContext.of_sdv( program_symbol_name, program_sdvs.interpret_py_source_file_that_must_exist( py_file_conf.path_sdv)) return NExArr( 'Environment: {}'.format(repr(environment)), PrimAndExeExpectation.of_exe( main_result=asrt_run.is_result_for_py_interpreter( py_run_programs.EXIT_CODE_FOR_SUCCESS)), arrangement_w_tcds( tcds_contents=py_file_rel_opt_conf. populator_for_relativity_option_root(DirContents([py_file])), symbols=program_symbol.symbol_table, process_execution=ProcessExecutionArrangement( process_execution_settings=ProcessExecutionSettings. with_environ(environment))))
def run_test(self): relativity_conf = relativity_options.conf_rel_any( self._missing_file_relativity) referenced_program_arguments = [ 'valid arg 1 of referenced', 'valid arg 2 of referenced' ] referenced_system_program_sdv = program_sdvs.system_program( string_sdvs.str_constant('valid-system-program'), ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants(referenced_program_arguments))) valid_program_symbol = ProgramSymbolContext.of_sdv( 'VALID_PROGRAM', referenced_system_program_sdv) invalid_argument_syntax = ArgumentOfExistingPathAbsStx( relativity_conf.path_abs_stx_of_name('non-existing-file')) reference_and_additional_invalid_argument = self.source_to_parse( valid_program_symbol.name, [invalid_argument_syntax], ) # ACT & ASSERT # self.integration_checker( ).check__abs_stx__layouts__source_variants__wo_input( self.put, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, reference_and_additional_invalid_argument, arrangement_w_tcds(symbols=valid_program_symbol.symbol_table, ), MultiSourceExpectation.of_const( symbol_references=valid_program_symbol.references_assertion, primitive=asrt.anything_goes(), execution=ExecutionExpectation( validation=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[ relativity_conf.directory_structure_partition], )), )
def test_disallowed_relativities(self): # ARRANGE # arguments_cases = [ NameAndValue( 'here doc', string_source_abs_stx.StringSourceOfStringAbsStx( rich_str_abs_stx.HereDocAbsStx('contents line\n'))), NameAndValue( 'raw string', string_source_abs_stx.StringSourceOfStringAbsStx.of_str( 'raw_string_argument')), NameAndValue( 'quoted string', string_source_abs_stx.StringSourceOfStringAbsStx.of_str( 'quoted string argument', QuoteType.SOFT)), ] for relativity in DISALLOWED_DST_RELATIVITIES: relativity_conf = conf_rel_any(relativity) for contents_case in arguments_cases: instruction_syntax = instr_abs_stx.create_w_explicit_contents( relativity_conf.path_abs_stx_of_name('file-name'), contents_case.value, ) with self.subTest(relativity=str(relativity), contents=contents_case.name): # ACT & ASSERT # check_invalid_syntax__abs_stx(self, instruction_syntax)
def check_parsing_with_different_source_variants( self, make_instruction_arguments: FilesMatcherArgumentsConstructor, model_constructor: ModelConstructorFromRelOptConf, default_relativity: RelOptionType, non_default_relativity: RelOptionType, main_result_for_positive_expectation: PassOrFail, contents_of_relativity_option_root: DirContents = empty_dir_contents(), following_symbols_setup: SymbolsArrEx = SymbolsArrEx.empty()): rel_opt_configs = [ rel_opt_conf.default_conf_rel_any(default_relativity), rel_opt_conf.conf_rel_any(non_default_relativity), ] for rel_opt_config in rel_opt_configs: for expectation_type_of_test_case in ExpectationType: etc = expectation_type_config__non_is_success( expectation_type_of_test_case) instruction_arguments = make_instruction_arguments.apply(etc) for source in equivalent_source_variants__for_expression_parser( self.put, Arguments(instruction_arguments)): self._check_( source, model_constructor(rel_opt_config), etc, main_result_for_positive_expectation, rel_opt_config, contents_of_relativity_option_root, following_symbols_setup=following_symbols_setup)
class TestProgramViaSymbolReference(unittest.TestCase): output_to_stderr = 'on stderr' py_file = File( 'exit-with-value-on-command-line.py', py_pgm_that_exits_with_1st_value_on_command_line(output_to_stderr)) py_file_rel_opt_conf = relativity_options.conf_rel_any( RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_that_executes_py_pgm_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_THAT_EXECUTES_PY_FILE', program_sdvs.interpret_py_source_file_that_must_exist( py_file_conf.path_sdv)) symbols = program_that_executes_py_pgm_symbol.symbol_table def test_check_zero_exit_code(self): EXECUTION_CHECKER.check__w_source_variants( self, args.sequence([ pgm_args.symbol_ref_command_line( self.program_that_executes_py_pgm_symbol.name), 0 ]).as_str, Arrangement.phase_agnostic( tcds=TcdsArrangement(tcds_contents=self.py_file_rel_opt_conf. populator_for_relativity_option_root( DirContents([self.py_file])), ), symbols=self.symbols), MultiSourceExpectation.phase_agnostic( main_result=result_assertions.equals(0, None), symbol_usages=asrt.matches_sequence([ self.program_that_executes_py_pgm_symbol. reference_assertion ]))) def test_check_non_zero_exit_code(self): exit_code = 87 EXECUTION_CHECKER.check__w_source_variants( self, args.sequence([ pgm_args.symbol_ref_command_line( self.program_that_executes_py_pgm_symbol.name), exit_code ]).as_str, Arrangement.phase_agnostic( tcds=TcdsArrangement(tcds_contents=self.py_file_rel_opt_conf. populator_for_relativity_option_root( DirContents([self.py_file])), ), symbols=self.symbols), MultiSourceExpectation.phase_agnostic( main_result=result_assertions.equals(exit_code, self.output_to_stderr), symbol_usages=asrt.matches_sequence([ self.program_that_executes_py_pgm_symbol. reference_assertion ])))
def test_referenced_file_does_not_exist__rel_hds(self): rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE) syntax = InstructionAbsStx( StringSourceOfFileAbsStx( rel_conf.path_abs_stx_of_name('non-existing-file'))) CHECKER.check_multi_source__abs_stx( self, syntax, Arrangement(), MultiSourceExpectation( validation=ValidationExpectationSvh.fails__pre_sds(), ))
def _check( self, output: StdOutputFilesContents, exit_code_cases: List[int], ignore_exit_code: bool, execution_expectation: ExecutionExpectation, ): # ARRANGE # py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP) for exit_code in exit_code_cases: with self.subTest(non_zero_exit_code=exit_code): py_file = File( 'exit-with-hard-coded-exit-code.py', py_programs.py_pgm_with_stdout_stderr_exit_code( stdout_output=output.out, stderr_output=output.err, exit_code=exit_code, ), ) py_file_conf = py_file_rel_opt_conf.named_file_conf( py_file.name) program_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_SYMBOL_NAME', program_sdvs.interpret_py_source_file_that_must_exist( py_file_conf.path_sdv)) # ACT && ASSERT # integration_check.CHECKER__PARSE_FULL.check( self, args.syntax_for_run( program_args.symbol_ref_command_elements( program_symbol.name), ignore_exit_code=ignore_exit_code, ).as_remaining_source, model_constructor.arbitrary(self), arrangement_w_tcds( symbols=program_symbol.symbol_table, tcds_contents=py_file_rel_opt_conf. populator_for_relativity_option_root( DirContents([py_file])), ), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=program_symbol. references_assertion), execution_expectation, ), )
def runTest(self): # ARRANGE # clashing_file_name = 'clashing-file' non_clashing_file_name = 'non-clashing-file' clash_cases: Sequence[NameAndValue[FileSystemElements]] = [ NameAndValue( 'exists as regular', [fs.File.empty(clashing_file_name)], ), NameAndValue( 'exists as dir', [fs.Dir.empty(clashing_file_name)], ), NameAndValue( 'exists as sym-link to regular', [fs.File.empty(non_clashing_file_name), fs.sym_link(clashing_file_name, non_clashing_file_name)], ), NameAndValue( 'exists as broken sym-link', [fs.sym_link(clashing_file_name, non_clashing_file_name)], ), ] src_dir_relativity = relativity_options.conf_rel_any(RelOptionType.REL_HDS_CASE) src_dir_symbol = PathDdvSymbolContext.of_no_suffix( 'SRC_PATH_SYMBOL', src_dir_relativity.relativity, accepted_relativities=RELATIVITY_VARIANTS__READ__BEFORE_ACT, ) arguments_syntax = abs_stx.CopyOfDirContentsAbsStx(src_dir_symbol.abstract_syntax) for clash_case in clash_cases: with self.subTest(clash_case.name): # ACT & ASSERT # integration_check.CHECKER.check__abs_stx( self, arguments_syntax, clash_case.value, Arrangement( symbols=src_dir_symbol.symbol_table, tcds=TcdsArrangement( tcds_contents=src_dir_relativity.populator_for_relativity_option_root__s( [fs.File.empty(clashing_file_name)] ) ) ), Expectation( ParseExpectation( source=asrt_source.is_at_end_of_line(1), symbol_references=src_dir_symbol.references_assertion, ), execution=ExecutionExpectation.is_any_hard_error() ), )
def _check_failing_validation_of_referenced_program__for_relativity(self, missing_file_relativity: RelOptionType): relativity_conf = relativity_options.conf_rel_any(missing_file_relativity) program_symbol_with_ref_to_non_exiting_exe_file = ProgramSymbolContext.of_sdv( 'PGM_WITH_REF_TO_EXE_FILE', program_sdvs.ref_to_exe_file( constant(simple_of_rel_option(relativity_conf.relativity_option, 'non-existing-exe-file'))) ) program_symbol_with_ref_to_non_exiting_file_as_argument = ProgramSymbolContext.of_sdv( 'PGM_WITH_ARG_WITH_REF_TO_FILE', program_sdvs.interpret_py_source_file_that_must_exist( constant(simple_of_rel_option(relativity_conf.relativity_option, 'non-existing-python-file.py'))) ) expectation = MultiSourceExpectation.of_const( symbol_references=asrt.anything_goes(), primitive=asrt.anything_goes(), execution=ExecutionExpectation( validation=FAILING_VALIDATION_ASSERTION_FOR_PARTITION[relativity_conf.directory_structure_partition], ) ) symbols = SymbolContext.symbol_table_of_contexts([ program_symbol_with_ref_to_non_exiting_exe_file, program_symbol_with_ref_to_non_exiting_file_as_argument, ]) arrangement = arrangement_w_tcds( symbols=symbols, ) cases = [ NameAndValue( 'executable does not exist', RawProgramOfSymbolReferenceAbsStx(program_symbol_with_ref_to_non_exiting_exe_file.name), ), NameAndValue( 'file referenced from argument does not exist', RawProgramOfSymbolReferenceAbsStx(program_symbol_with_ref_to_non_exiting_file_as_argument.name), ), ] for case in cases: with self.subTest(case=case.name): # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, case.value, arrangement, expectation, )
def test_disallowed_relativities(self): # ARRANGE # for relativity in DISALLOWED_DST_RELATIVITIES: relativity_conf = conf_rel_any(relativity) instruction_syntax = abs_stx.without_contents( relativity_conf.path_abs_stx_of_name('file-name')) # ACT & ASSERT # check_invalid_syntax__abs_stx(self, instruction_syntax, sub_test_identifiers={ 'relativity': relativity, })
def runTest(self): # ARRANGE # py_file = File('stdin-to-upper.py', _PGM_THAT_OUTPUTS_STDIN_IN_UPPER_CASE) py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_symbol = ProgramSymbolContext.of_sdv( 'PROGRAM_THAT_EXECUTES_PY_FILE', program_sdvs.interpret_py_source_file_that_must_exist(py_file_conf.path_sdv) ) input_model_lines = [ 'the\n', 'input\n', 'model', ] expected_output_model_lines = list(map(str.upper, input_model_lines)) for with_ignored_exit_code in [False, True]: with self.subTest(with_ignored_exit_code=with_ignored_exit_code): # ACT && ASSERT # integration_check.CHECKER__PARSE_FULL.check__w_source_variants_for_full_line_parser( self, args.syntax_for_run( program_args.symbol_ref_command_elements(program_symbol.name), ignore_exit_code=with_ignored_exit_code, ), model_constructor.of_lines(self, input_model_lines), arrangement_w_tcds( tcds_contents=py_file_rel_opt_conf.populator_for_relativity_option_root( DirContents([py_file]) ), symbols=program_symbol.symbol_table, ), MultiSourceExpectation( symbol_references=program_symbol.references_assertion, execution=ExecutionExpectation( main_result=asrt_string_source.pre_post_freeze__matches_lines( asrt.equals(expected_output_model_lines), may_depend_on_external_resources=asrt.equals(True), frozen_may_depend_on_external_resources=asrt.anything_goes(), ) ), primitive=prim_asrt__constant( asrt_string_transformer.is_identity_transformer(False) ), ), )
def _check_of_invalid_src_file( self, is_after_act_2_every_src_file_rel_conf: Callable[ [bool], Sequence[RelativityOptionConfiguration]], step_of_expected_failure: Step): # ARRANGE # transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) symbols = transformer.symbol_table dst_file_rel_conf = conf_rel_any(RelOptionType.REL_TMP) expectation_ = self._expect_failure_in(step_of_expected_failure) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) for src_file_rel_conf in is_after_act_2_every_src_file_rel_conf( phase_is_after_act): contents_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_rel_conf.path_abs_stx_of_name( self.src_file_name))) for actual_src_file_variant in self.src_file_variants: for contents_arguments in contents_builder.with_and_without_transformer_cases( transformer.abstract_syntax): instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_file_rel_conf.path_abs_stx_of_name( 'dst-file.txt'), contents_arguments.value, ) # ACT & ASSERT # checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, tcds_contents=src_file_rel_conf. populator_for_relativity_option_root( actual_src_file_variant.value), ), symbols=symbols, ), expectation_, sub_test_identifiers={ 'phase_is_after_act': phase_is_after_act, 'contents': contents_arguments.name, 'relativity_of_src_path': src_file_rel_conf.name, })
def runTest(self): # ARRANGE # model_contents = DirContents([ Dir('a-dir', [File.empty('a-file-in-pruned-dir')]), ]) file_matcher = FileMatcherSymbolContextOfPrimitiveConstant( 'FILE_MATCHER_SYMBOL', True, ) files_matcher__parsed = FilesMatcherSymbolContext.of_primitive( 'FILES_MATCHER_1', files_matcher_test_impl.FilesMatcherNumFilesTestImpl(1)) symbols = [file_matcher, files_matcher__parsed] files_matcher_bin_op_expr = fsm_args.conjunction([ fm_args.SymbolReferenceWReferenceSyntax( files_matcher__parsed.name), fsm_args.Custom('after bin op'), ]) arguments = fsm_args.Prune( fm_args.SymbolReferenceWReferenceSyntax(file_matcher.name), files_matcher_bin_op_expr, ) model_rel_opt_conf = rel_opt_confs.conf_rel_any(RelOptionType.REL_ACT) # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check( self, arguments.as_remaining_source, models.model_constructor__recursive( model_rel_opt_conf.path_sdv_for_root_dir()), arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols), tcds_contents=model_rel_opt_conf. populator_for_relativity_option_root(model_contents)), Expectation( ParseExpectation( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=' '.join([ files_matcher_bin_op_expr.operator, files_matcher_bin_op_expr.operands[1].as_str, ])), symbol_references=SymbolContext. references_assertion_of_contexts(symbols), ), ExecutionExpectation( main_result=matcher_assertions.is_matching_success(), ), ), )
def _check_failing_validation___for_relativity( self, missing_file_relativity: RelOptionType): relativity_conf = relativity_options.conf_rel_any( missing_file_relativity) invalid_argument_syntax = ArgumentOfExistingPathAbsStx( relativity_conf.path_abs_stx_of_name('non-existing-file')) arguments_cases = [ NameAndValue( '1st argument fails validation', [invalid_argument_syntax], ), NameAndValue( '2nd argument fails validation', [ ArgumentOfRichStringAbsStx.of_str('valid1'), invalid_argument_syntax, ArgumentOfRichStringAbsStx.of_str('valid2') ], ), ] for pgm_and_args_case in pgm_and_args_cases.cases__w_argument_list__excluding_program_reference( ): for arguments_case in arguments_cases: pgm_w_args = PgmAndArgsWArgumentsAbsStx( pgm_and_args_case.pgm_and_args, arguments_case.value) with self.subTest(pgm_and_args=pgm_and_args_case.name, arguments=arguments_case.name): # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_consume_until_end_of_last_line__s__nsc, pgm_w_args, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( pgm_and_args_case.symbols), tcds_contents=pgm_and_args_case.tcds, ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( pgm_and_args_case.symbols), primitive=asrt.anything_goes(), execution=ExecutionExpectation( validation= FAILING_VALIDATION_ASSERTION_FOR_PARTITION[ relativity_conf. directory_structure_partition], )), )
def runTest(self): # ARRANGE # rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_ACT) syntax = InstructionAbsStx( StringSourceOfFileAbsStx( rel_conf.path_abs_stx_of_name('non-existing-stdin-file.txt'))) # ACT & ASSERT # CHECKER.check_multi_source__abs_stx( self, syntax, Arrangement(symbols=rel_conf.symbols.in_arrangement(), ), MultiSourceExpectation( symbols_after_parse=rel_conf.symbols.usages_expectation(), settings_builder=asrt_settings.stdin_is_present_but_invalid(), ))
def configurations() -> Sequence[RelativityConfiguration]: all_except_rel_result = set(RelOptionType).difference( {RelOptionType.REL_RESULT}) for_non_default = [ RelativityConfiguration( relativity_options.conf_rel_any(rel_option_type)) for rel_option_type in all_except_rel_result ] return for_non_default + [ RelativityConfiguration( relativity_options.default_conf_rel_any( RelOptionType.REL_HDS_CASE)), ]
class StdinCheckWithProgramWExitCode0ForSuccess: _SRC_FILE_REL_CONF = rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE) _CHECKER_PROGRAM_FILE_NAME = 'read-and-check-stdin.py' _CHECKER_PROGRAM_PY_SRC = """\ import sys expected = sys.argv[1] actual = sys.stdin.read() if expected == actual: sys.exit(0) else: sys.stderr.write('\\n'.join([ 'Expected: ' + repr(expected), 'Actual : ' + repr(actual), ])) sys.stderr.write('\\n') sys.exit(1) """ def program_that_checks_stdin__syntax( self, program_stdin: str, additional_expected_stdin: str = '', ) -> FullProgramAbsStx: expected_contents_arg_syntax = ArgumentOfRichStringAbsStx.of_str( program_stdin + additional_expected_stdin, QuoteType.HARD) checker_pgm_syntax = ProgramOfPythonInterpreterAbsStx.of_execute_python_src_file( self._SRC_FILE_REL_CONF.path_abs_stx_of_name( self._CHECKER_PROGRAM_FILE_NAME), [expected_contents_arg_syntax], ) return FullProgramAbsStx( checker_pgm_syntax, stdin=StringSourceOfStringAbsStx.of_str_hard(program_stdin)) @property def tcds_contents(self) -> TcdsPopulator: return self._SRC_FILE_REL_CONF.populator_for_relativity_option_root( DirContents([ File(self._CHECKER_PROGRAM_FILE_NAME, self._CHECKER_PROGRAM_PY_SRC) ])) @property def exit_code_of_successful_application(self) -> int: return 0
def test_referenced_file_is_a_directory__pre_sds(self): the_dir = Dir.empty('a-directory') rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_HDS_CASE) syntax = InstructionAbsStx( StringSourceOfFileAbsStx( rel_conf.path_abs_stx_of_name(the_dir.name))) CHECKER.check_multi_source__abs_stx( self, syntax, Arrangement( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents([the_dir])), ), MultiSourceExpectation( validation=ValidationExpectationSvh.fails__pre_sds(), ), )
def runTest(self): # ARRANGE # checked_dir_rel_conf = relativity_options.conf_rel_any(RelOptionType.REL_ACT) checked_dir_populator = checked_dir_rel_conf.populator_for_relativity_option_root( DirContents([ File.empty('a-file-so-that-checked-dir-is-not-empty') ] ) ) file_matcher = FileMatcherSymbolContextOfPrimitiveConstant( 'MATCHER', True, ) after_bin_op = 'after bin op' fm_argument = fm_args.conjunction([ fm_args.SymbolReference(file_matcher.name), fm_args.Custom(after_bin_op), ]) # ACT & ASSERT # for quantifier in Quantifier: arguments = args.Quantification(quantifier, fm_argument) with self.subTest(quantifier): # ACT & ASSERT # integration_check.CHECKER__PARSE_SIMPLE.check( self, source=arguments.as_remaining_source, input_=model.model_constructor__non_recursive( path_sdvs.of_rel_option(checked_dir_rel_conf.relativity) ), arrangement=arrangement_w_tcds( symbols=file_matcher.symbol_table, tcds_contents=checked_dir_populator ), expectation=Expectation( ParseExpectation( source=asrt_source.is_at_line( current_line_number=1, remaining_part_of_current_line=fm_argument.operator + ' ' + after_bin_op), symbol_references=file_matcher.references_assertion ), ExecutionExpectation( main_result=asrt_matching_result.matches_value(file_matcher.result_value) ) ), )
def test_referenced_file_is_a_directory__post_sds(self): the_dir = Dir.empty('a-directory') rel_conf = rel_opt_conf.conf_rel_any(RelOptionType.REL_TMP) syntax = InstructionAbsStx( StringSourceOfFileAbsStx( rel_conf.path_abs_stx_of_name(the_dir.name))) CHECKER.check_multi_source__abs_stx( self, syntax, Arrangement( tcds_contents=rel_conf.populator_for_relativity_option_root( DirContents([the_dir])), ), MultiSourceExpectation( settings_builder=asrt_settings.stdin_is_present_but_invalid(), ), )
def _check_of_invalid_src_file( self, src_file_relativity: RelOptionType, validation: ValidationAssertions, ): # ARRANGE # checker = integration_check.checker(parse_check.rel_opts_conf_of_single(src_file_relativity)) expectation_ = MultiSourceExpectation( symbol_references=asrt.anything_goes(), execution=ExecutionExpectation( validation=validation ) ) src_file_rel_conf = conf_rel_any(src_file_relativity) transformer = StringTransformerSymbolContext.of_primitive( 'TRANSFORMER_SYMBOL', string_transformers.to_uppercase(), ) symbols = transformer.symbol_table contents_builder = string_source_abs_stx.TransformableAbsStxBuilder( string_source_abs_stx.StringSourceOfFileAbsStx( src_file_rel_conf.path_abs_stx_of_name(self.src_file_name) ) ) for actual_src_file_variant in self.src_file_variants: for contents_arguments in contents_builder.with_and_without_transformer_cases( transformer.abstract_syntax): with self.subTest(src_file_variant=actual_src_file_variant.name, contents=contents_arguments.name, relativity_of_src_path=src_file_rel_conf.option_argument): # ACT & ASSERT # checker.check__abs_stx__layouts__std_source_variants__wo_input( self, OptionallyOnNewLine(contents_arguments.value), arrangement_w_tcds( tcds_contents=src_file_rel_conf.populator_for_relativity_option_root( actual_src_file_variant.value), symbols=symbols, ), expectation_, )
def exit_code_exe_cases( program_symbol_name: str, exit_code_symbol_name: str, ) -> Sequence[NExArr[PrimAndExeExpectation[MatcherWTrace, MatchingResult], Arrangement]]: py_file = File( 'exit-with-value-on-command-line.py', py_programs.py_pgm_that_exits_with_1st_value_on_command_line('')) py_file_rel_opt_conf = rel_opt.conf_rel_any(RelOptionType.REL_TMP) py_file_conf = py_file_rel_opt_conf.named_file_conf(py_file.name) program_symbol = ProgramSymbolContext.of_sdv( program_symbol_name, program_sdvs.interpret_py_source_file_that_must_exist( py_file_conf.path_sdv)) def case( exit_code_from_program: int ) -> NExArr[PrimAndExeExpectation[MatcherWTrace, MatchingResult], Arrangement]: exit_code_symbol = StringIntConstantSymbolContext( exit_code_symbol_name, exit_code_from_program) return NExArr( 'Exit code {}'.format(exit_code_from_program), PrimAndExeExpectation.of_exe( main_result=asrt_run.is_result_for_py_interpreter( exit_code_from_program)), arrangement_w_tcds( tcds_contents=py_file_rel_opt_conf. populator_for_relativity_option_root(DirContents([py_file])), symbols=SymbolContext.symbol_table_of_contexts([ program_symbol, exit_code_symbol, ]), )) exit_code_from_program_cases = [0, 1, 3, 69, 72] return [ case(exit_code_from_program) for exit_code_from_program in exit_code_from_program_cases ]