def test(self): expected_defined_symbol = ConstantSuffixPathDdvSymbolContext( 'name', RelOptionType.REL_ACT, 'component') argument_cases = [ NameAndValue('value on same line', '{rel_act} {suffix}'), NameAndValue('value on following line', '{new_line} {rel_act} {suffix}'), ] for argument_case in argument_cases: with self.subTest(arguments=argument_case.name): instruction_argument = src2( ValueType.PATH, expected_defined_symbol.name, argument_case.value, suffix=expected_defined_symbol.path_suffix) for source in equivalent_source_variants__with_source_check__consume_last_line( self, instruction_argument): INSTRUCTION_CHECKER.check( self, source, Arrangement.phase_agnostic(), Expectation.phase_agnostic( symbol_usages=asrt.matches_singleton_sequence( expected_defined_symbol. assert_matches_definition_of_sdv), symbols_after_main=assert_symbol_table_is_singleton( expected_defined_symbol.name, expected_defined_symbol.value. assert_matches_container_of_sdv)))
def _check_cases_for_dst_file_setup__expect_pre_sds_validation_failure( self, dst_file_name: str, additional_symbols: Iterable[Entry] = (), ): dst_file = path_abs_stx.DefaultRelPathAbsStx(dst_file_name) cases_data = self._file_contents_cases() for file_contents_case in cases_data.file_contents_cases: instruction_syntax = instr_abs_stx.InstructionAbsStx( dst_file, file_contents_case.value, ) symbols = cases_data.symbols.copy() symbols.add_all(additional_symbols) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest( file_contents_variant=file_contents_case.name, phase_is_after_act=phase_is_after_act): # ACT & ASSERT # checker.check__abs_stx( self, instruction_syntax, Arrangement.phase_agnostic(symbols=symbols, ), Expectation.phase_agnostic_2( validation=ValidationAssertions. pre_sds_fails__w_any_msg(), symbol_usages=asrt.anything_goes(), ))
def test(self): instruction_argument = src2( ValueType.PATH, 'ASSIGNED_NAME', '{rel_symbol} REFERENCED_SYMBOL component') for source in equivalent_source_variants__with_source_check__consume_last_line( self, instruction_argument): expected_path_sdv = path_sdvs.rel_symbol( SymbolReference( 'REFERENCED_SYMBOL', ReferenceRestrictionsOnDirectAndIndirect( PathAndRelativityRestriction( type_parser.REL_OPTIONS_CONFIGURATION. accepted_relativity_variants))), path_part_sdvs.from_constant_str('component')) expected_symbol_value = PathSymbolValueContext.of_sdv( expected_path_sdv) expected_symbol = PathSymbolContext('ASSIGNED_NAME', expected_symbol_value) INSTRUCTION_CHECKER.check( self, source, Arrangement.phase_agnostic(), Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence( [expected_symbol.assert_matches_definition_of_sdv]), symbols_after_main=assert_symbol_table_is_singleton( expected_symbol.name, expected_symbol_value. assert_matches_container_of_sdv)))
def test_destination_already_exists__without_explicit_destination(self): # ARRANGE # file_name = 'existing-file' file_to_install = DirContents([(File(file_name, 'contents'))]) for parser_case in _EXECUTION_CHECKERS: with self.subTest(parser=parser_case.name): # ACT & ASSERT # parser_case.value.check( self, args.copy( defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(file_name) ).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY, hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds( file_to_install), sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds( DirContents([File.empty(file_name)]) ), ) ), Expectation.phase_agnostic_2( main_result=asrt_text_doc.is_any_text(), ) )
def test_destination_already_exists_in_destination_directory(self): src = 'src-file-name' dst = 'dst-dir-name' home_dir_contents = DirContents([(File.empty(src))]) cwd_dir_contents = DirContents([Dir(dst, [File.empty(src)])]) for parser_case in _EXECUTION_CHECKERS: with self.subTest(parser=parser_case.name): # ACT & ASSERT # parser_case.value.check( self, args.copy( defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name(src), defs.DEFAULT_DST_REL_OPT.path_argument_of_rel_name(dst) ).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY, hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds( home_dir_contents), sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds( cwd_dir_contents ), ) ), Expectation.phase_agnostic( main_result=asrt_text_doc.is_any_text(), ), )
def test_copy_directory(self): src_path_arg = defs.DEFAULT_SRC_REL_OPT.path_argument_of_rel_name('existing-dir') files_to_install = DirContents([Dir(src_path_arg.name, [File('a', 'a'), Dir('d', []), Dir('d2', [File('f', 'f')]) ])]) for execution_checker in _EXECUTION_CHECKERS: with self.subTest(parser=execution_checker.name): execution_checker.value.check( self, args.copy(src_path_arg).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY, hds_contents=defs.DEFAULT_SRC_REL_OPT.populator_for_relativity_option_root__hds( files_to_install), ), ), Expectation.phase_agnostic_2( main_side_effects_on_sds=sds_contents_check.cwd_contains_exactly( files_to_install) ) )
def test(self): with tmp_dir() as abs_path_of_dir_containing_last_file_base_name: fs_location_info = FileSystemLocationInfo( FileLocationInfo( abs_path_of_dir_containing_last_file_base_name)) instruction_argument = src2(ValueType.PATH, 'name', '{rel_source_file} component') for source in equivalent_source_variants__with_source_check__consume_last_line( self, instruction_argument): expected_path_sdv = path_sdvs.constant( path_ddvs.rel_abs_path( abs_path_of_dir_containing_last_file_base_name, path_ddvs.constant_path_part('component'))) expected_symbol_value = PathSymbolValueContext.of_sdv( expected_path_sdv) expected_symbol = PathSymbolContext('name', expected_symbol_value) INSTRUCTION_CHECKER.check( self, source, Arrangement.phase_agnostic( fs_location_info=fs_location_info), Expectation.phase_agnostic( symbol_usages=asrt.matches_singleton_sequence( expected_symbol.assert_matches_definition_of_sdv), symbols_after_main=assert_symbol_table_is_singleton( 'name', expected_symbol_value. assert_matches_container_of_sdv)))
def test_successful_step_sequence(self): validate_pre_sds = 'validate_pre_sds' validate_post_sds = 'validate_post_sds' main = 'main' expected_recordings = [ validate_pre_sds, validate_post_sds, main, ] recorder = [] def recording_of(s: str) -> Callable[[InstructionEnvironmentForPostSdsStep, InstructionSettings, OsServices], None]: def ret_val(*args): recorder.append(s) return ret_val instruction_that_records_steps = instruction_embryo_that__phase_agnostic( validate_pre_sds_initial_action=recording_of(validate_pre_sds), validate_post_sds_initial_action=recording_of(validate_post_sds), main_initial_action=recording_of(main)) self._check( ParserThatGives(instruction_that_records_steps), single_line_source(), Arrangement.phase_agnostic(), Expectation.phase_agnostic()) self.assertEqual(expected_recordings, recorder, 'step execution sequence')
def test_assignment_of_single_constant_line(self): value_str = 'value' symbol_name = 'name1' sb = SB.new_with(value_str=value_str, symbol_name=symbol_name) source = sb.lines( here_doc_lines(first_line_start='{string_type} {symbol_name} = ', marker='EOF', contents_lines=['{value_str}']) + ['following line'] ) # EXPECTATION # expected_symbol = StringConstantSymbolContext(symbol_name, value_str + '\n') expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ expected_symbol.assert_matches_definition_of_sdv ]), symbols_after_main=assert_symbol_table_is_singleton( symbol_name, expected_symbol.value.assert_matches_container_of_sdv, ), source=asrt_source.is_at_beginning_of_line(4) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_assignment_of_symbols_and_constant_text_within_soft_quotes(self): # ARRANGE # referred_symbol1 = SymbolWithReferenceSyntax('referred_symbol_1') referred_symbol2 = SymbolWithReferenceSyntax('referred_symbol_2') assigned_symbol = StringSymbolContext.of_sdv( 'defined_symbol', string_sdv_from_fragments([ symbol(referred_symbol1.name), constant(' between '), symbol(referred_symbol2.name), ])) source = single_line_source('{string_type} {name} = {soft_quote}{sym_ref1} between {sym_ref2}{soft_quote}', soft_quote=SOFT_QUOTE_CHAR, name=assigned_symbol.name, sym_ref1=referred_symbol1, sym_ref2=referred_symbol2) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_assignment_of_single_symbol_reference(self): # ARRANGE # referred_symbol = SymbolWithReferenceSyntax('referred_symbol') expected_sdv = string_sdv_from_fragments([symbol(referred_symbol.name), constant('\n')]) assigned_symbol = StringSymbolContext.of_sdv( 'defined_symbol', expected_sdv, ) sb = SB.new_with(referred_symbol=referred_symbol, name_of_defined_symbol=assigned_symbol.name) source = sb.lines( here_doc_lines(first_line_start='{string_type} {name_of_defined_symbol} = ', marker='EOF', contents_lines=[str(referred_symbol)]) ) # EXPECTATION # expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_source(self): self._check( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, single_line_source(), Arrangement.phase_agnostic(), Expectation.phase_agnostic(source=asrt.IsInstance(ParseSource)), )
def test_copy_file__src_rel_non_hds(self): for execution_checker in _EXECUTION_CHECKERS: for relativity_option in source_relativity_options__non_hds(): with self.subTest(parser=execution_checker.name, relativity=relativity_option.test_case_description): file_arg = relativity_option.path_argument_of_rel_name('existing-file') file_to_install = DirContents([(File(file_arg.name, 'contents'))]) execution_checker.value.check( self, args.copy(file_arg).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action=MAKE_SUB_DIR_OF_SDS_CURRENT_DIRECTORY, non_hds_contents=relativity_option.populator_for_relativity_option_root__non_hds( file_to_install ), ), symbols=relativity_option.symbols.in_arrangement(), ), Expectation.phase_agnostic_2( symbol_usages=relativity_option.symbols.usages_expectation(), main_side_effects_on_sds=sds_contents_check.cwd_contains_exactly(file_to_install), ) )
def test_symbol_reference_in_dst_file_argument(self): dst_path_symbol = ConstantSuffixPathDdvSymbolContext( 'dst_path_symbol', RelOptionType.REL_ACT, 'dst-file.txt', ACCEPTED_DST_RELATIVITY_VARIANTS) string_value = rich_str_abs_stx.HereDocAbsStx( 'single line in here doc\n') instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_path_symbol.abstract_syntax, string_source_abs_stx.StringSourceOfStringAbsStx(string_value), ) expected_file = fs.File(dst_path_symbol.path_suffix, string_value.value) integration_check.CHECKER__BEFORE_ACT.check__abs_stx( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, ), symbols=dst_path_symbol.symbol_table, ), Expectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=asrt.matches_singleton_sequence( dst_path_symbol.reference_assertion), main_side_effects_on_sds=dir_contains_exactly( dst_path_symbol.rel_option_type, fs.DirContents([expected_file])), ))
def test_fail_if_instruction_is_not_setup_phase_aware(self): with self.assertRaises(utils.TestError): self._check( ParserThatGives(instruction_embryo_that__phase_agnostic()), single_line_source(), Arrangement.setup_phase_aware(), Expectation.setup_phase_aware(), )
def test_that_default_expectation_assumes_no_symbol_usages(self): unexpected_symbol_usages = [ data_references.reference_to__on_direct_and_indirect('symbol_name')] self._check_source_and_exe_variants__failing_assertions( ParserThatGives( instruction_embryo_that__phase_agnostic( symbol_usages=do_return(unexpected_symbol_usages))), Arrangement.phase_agnostic(), Expectation.phase_agnostic(), )
def _test_symbol_reference_in_dst_file_and_contents( self, symbol_ref_syntax_2_contents_arguments: Callable[ [str], StringSourceAbsStx], symbol_value_2_expected_contents: Callable[[str], str]): sub_dir_symbol = ConstantSuffixPathDdvSymbolContext( 'sub_dir_symbol', RelOptionType.REL_ACT, 'sub-dir', ACCEPTED_DST_RELATIVITY_VARIANTS, ) contents_symbol = StringConstantSymbolContext( 'contents_symbol_name', 'contents symbol value', default_restrictions=asrt_rest.is__w_str_rendering(), ) expected_file_contents = symbol_value_2_expected_contents( contents_symbol.str_value) expected_file = fs.File('a-file-name.txt', expected_file_contents) symbols = [sub_dir_symbol, contents_symbol] expected_symbol_references = SymbolContext.references_assertion_of_contexts( symbols) symbol_table = SymbolContext.symbol_table_of_contexts(symbols) contents_arguments = symbol_ref_syntax_2_contents_arguments( symbol_reference_syntax_for_name(contents_symbol.name)) instruction_syntax = instr_abs_stx.create_w_explicit_contents( path_abs_stx.PathStringAbsStx.of_plain_components( [sub_dir_symbol.name__sym_ref_syntax, expected_file.name]), contents_arguments, ) integration_check.CHECKER__AFTER_ACT.check__abs_stx( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, ), symbols=symbol_table, ), Expectation.phase_agnostic( main_result=IS_SUCCESS, symbol_usages=expected_symbol_references, main_side_effects_on_sds=dir_contains_exactly( sub_dir_symbol.rel_option_type, fs.DirContents( [fs.Dir(sub_dir_symbol.path_suffix, [expected_file])])), ))
def runTest(self): # ARRANGE # test_setup = StdinCheckWithProgramWExitCode0ForSuccess() # ACT & ASSERT # EXECUTION_CHECKER.check__abs_stx( self, test_setup.program_that_checks_stdin__syntax( 'the contents of stdin'), Arrangement.phase_agnostic(tcds=TcdsArrangement( tcds_contents=test_setup.tcds_contents, ), ), Expectation.phase_agnostic(main_result=result_assertions.equals( test_setup.exit_code_of_successful_application, None)), )
def test_symbol_references(self): file_to_interpret = fs.File( 'python-logic_symbol_utils.py', python_program_that_exits_with_code_given_as_first_cl_arg) file_to_interpret_symbol = StringConstantSymbolContext( 'file_to_interpret_symbol', file_to_interpret.file_name) python_interpreter_symbol = StringConstantSymbolContext( 'python_interpreter_symbol', sys.executable) exit_code_symbol = StringIntConstantSymbolContext( 'exit_code_symbol', 72) argument = ' {python_interpreter} {interpret_option} {file_to_interpret} "{exit_code}"'.format( python_interpreter=python_interpreter_symbol.name__sym_ref_syntax, interpret_option=args.option( syntax_elements.EXISTING_FILE_OPTION_NAME).as_str, file_to_interpret=file_to_interpret_symbol.name__sym_ref_syntax, exit_code=exit_code_symbol.name__sym_ref_syntax, ) following_line = 'following line' source = remaining_source(argument, [following_line]) arrangement = Arrangement.phase_agnostic( tcds=TcdsArrangement(tcds_contents=TcdsPopulatorForRelOptionType( path_relativities.ALL_REL_OPTIONS_ARG_CONFIG.options. default_option, fs.DirContents([file_to_interpret])), ), symbols=SymbolContext.symbol_table_of_contexts([ python_interpreter_symbol, file_to_interpret_symbol, exit_code_symbol, ]), ) expectation = Expectation.phase_agnostic( source=assert_source(current_line_number=asrt.equals(2), column_index=asrt.equals(0)), symbol_usages=asrt.matches_sequence([ python_interpreter_symbol.usage_assertion__path_or_string( syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options. accepted_relativity_variants), file_to_interpret_symbol.usage_assertion__path_or_string( path_relativities.ALL_REL_OPTIONS_ARG_CONFIG.options. accepted_relativity_variants), exit_code_symbol.usage_assertion__w_str_rendering, ]), main_result=result_assertions.equals(exit_code_symbol.int_value, ''), ) parser = sut.embryo_parser('instruction-name') embryo_check.check(self, parser, source, arrangement, expectation)
def test_successful_parse_and_application_of_non_trivial_matcher(self): # ARRANGE # defined_name = 'defined_name' expected_container = matches_container( asrt.equals(ValueType.FILES_MATCHER), type_sdv_assertions.matches_sdv_of_files_matcher() ) not_num_files_beginning_with_a_eq_1_arg = self._not_num_files_beginning_with_a_eq_1_arg() cases = [ NEA('should match', expected=matcher_assertions.is_matching_success(), actual=DirContents([ File.empty('a.x'), File.empty('a.y'), File.empty('b.x'), File.empty('b.y'), ]) ), NEA('should not match', expected=matcher_assertions.is_arbitrary_matching_failure(), actual=DirContents([ File.empty('a.x'), File.empty('b.y'), File.empty('b.x'), ]) ), ] for case in cases: source = single_line_source( src2(ValueType.FILES_MATCHER, defined_name, not_num_files_beginning_with_a_eq_1_arg), ) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ), instruction_environment= AssertApplicationOfMatcherInSymbolTable(defined_name, actual_dir_contents=case.actual, expected_matcher_result=case.expected), )
def test_that_fails_due_to_missing_symbol_reference(self): symbol_usages_of_instruction = [] self._check_source_and_exe_variants__failing_assertions( ParserThatGives( instruction_embryo_that__phase_agnostic( symbol_usages=do_return(symbol_usages_of_instruction))), Arrangement.phase_agnostic(), Expectation.phase_agnostic( symbol_usages=asrt.matches_singleton_sequence( matches_data_type_symbol_reference( 'symbol_name', reference_restrictions.is_any_type_w_str_rendering() ) )), )
class TestSuccessfulScenarios(unittest.TestCase): def test_successful_parse_of_arbitrary_matcher(self): defined_name = 'defined_name' file_name = 'the-file-name' # ARRANGE # argument_cases = [ NameAndValue('value on same line', '{files_condition}' ), NameAndValue('value on following line', '{new_line} {files_condition}' ), ] for case in argument_cases: with self.subTest(case.name): source = remaining_source( src2(ValueType.FILES_CONDITION, defined_name, case.value, files_condition=arg_syntax.FilesCondition([arg_syntax.FileCondition(file_name)])), ) # EXPECTATION # expected_container = matches_container( asrt.equals(ValueType.FILES_CONDITION), type_sdv_assertions.matches_sdv_of_files_condition_constant( primitive_value=asrt_primitive.files_matches({ PurePosixPath(file_name): asrt.is_none }) ) ) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def _check_cases_for_dst_file_setup__w_relativity_options( self, dst_file_name: str, dst_root_contents_before_execution: DirContents, ): cases_data = self._file_contents_cases() dst_file_relativity_cases = [ conf_rel_non_hds(RelNonHdsOptionType.REL_CWD), conf_rel_non_hds(RelNonHdsOptionType.REL_ACT), ] for rel_opt_conf in dst_file_relativity_cases: non_hds_contents = rel_opt_conf.populator_for_relativity_option_root__non_hds( dst_root_contents_before_execution) dst_file = rel_opt_conf.path_abs_stx_of_name(dst_file_name) for file_contents_case in cases_data.file_contents_cases: instruction_syntax = instr_abs_stx.InstructionAbsStx( dst_file, file_contents_case.value, ) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest( file_contents_variant=file_contents_case.name, dst_file_variant=rel_opt_conf.name, phase_is_after_act=phase_is_after_act): # ACT & ASSERT # checker.check__abs_stx( self, instruction_syntax, Arrangement.phase_agnostic( tcds=TcdsArrangement( pre_population_action= SETUP_CWD_INSIDE_SDS_BUT_NOT_A_SDS_DIR__PLAIN, tcds_contents=cases_data. pre_existing_files, non_hds_contents=non_hds_contents, ), symbols=cases_data.symbols, ), Expectation.phase_agnostic_2( main_result=IS_FAILURE, symbol_usages=asrt.anything_goes(), ))
def runTest(self): # ARRANGE # dst_file_name = 'dst-file_name-file.txt' src_file = File('src-file_name-file.txt', 'contents') home_dir_contents = DirContents([src_file]) expected_destination_dir_contents = DirContents([File(dst_file_name, src_file.contents)]) dst_rel_option = rel_opt_conf.symbol_conf_rel_non_hds( defs.ARBITRARY_LEGAL_RELATIVITY__DST__NON_HDS, 'DST_SYMBOL', defs.PATH_RELATIVITY_VARIANTS__DST, ) for phase_is_after_act in [False, True]: with self.subTest(phase_is_after_act=phase_is_after_act): checker = instruction_embryo_check.Checker(sut.EmbryoParser(phase_is_after_act)) src_rel_option = rel_opt_conf.symbol_conf_rel_hds( defs.ARBITRARY_LEGAL_RELATIVITY__SRC__HDS, 'SRC_SYMBOL', defs.path_relativity_variants__src(phase_is_after_act), ) # ACT & ASSERT # checker.check( self, args.copy(src_rel_option.path_argument_of_rel_name(src_file.name), dst_rel_option.path_argument_of_rel_name(dst_file_name) ).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement( hds_contents=src_rel_option.populator_for_relativity_option_root__hds(home_dir_contents), ), symbols=SymbolContext.symbol_table_of_contexts( src_rel_option.symbols.contexts_for_arrangement() + dst_rel_option.symbols.contexts_for_arrangement() ) ), Expectation.phase_agnostic_2( symbol_usages=asrt.matches_sequence( src_rel_option.symbols.usage_expectation_assertions() + dst_rel_option.symbols.usage_expectation_assertions() ), main_side_effects_on_sds=sds_contents_check.non_hds_dir_contains_exactly( dst_rel_option.root_dir__non_hds, expected_destination_dir_contents), ), )
def test_symbol_references(self): python_interpreter_symbol = StringConstantSymbolContext( 'python_interpreter_symbol', sys.executable) execute_program_option_symbol = StringConstantSymbolContext( 'execute_program_option', '-c') exit_code_symbol = StringIntConstantSymbolContext( 'exit_code_symbol', 87) argument = ' {python_interpreter} {execute_program_option} {source_option} exit({exit_code}) '.format( python_interpreter=python_interpreter_symbol.name__sym_ref_syntax, execute_program_option=execute_program_option_symbol. name__sym_ref_syntax, source_option=syntax_elements. REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER, exit_code=exit_code_symbol.name__sym_ref_syntax, ) arrangement = Arrangement.phase_agnostic( symbols=SymbolContext.symbol_table_of_contexts([ python_interpreter_symbol, execute_program_option_symbol, exit_code_symbol, ]), tcds=TcdsArrangement(), ) source = remaining_source(argument, ['following line']) expectation = Expectation.phase_agnostic( source=assert_source(current_line_number=asrt.equals(2), column_index=asrt.equals(0)), symbol_usages=asrt.matches_sequence([ python_interpreter_symbol.usage_assertion__path_or_string( syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options. accepted_relativity_variants), execute_program_option_symbol.usage_assertion__w_str_rendering, exit_code_symbol.usage_assertion__w_str_rendering, ]), main_result=result_assertions.equals(exit_code_symbol.int_value, ''), ) parser = sut.embryo_parser('instruction-name') embryo_check.check(self, parser, source, arrangement, expectation)
def test_assignment_of_single_symbol_reference(self): # ARRANGE # referred_symbol = SymbolWithReferenceSyntax('referred_symbol') assigned_symbol = StringSymbolContext.of_sdv('defined_symbol', string_sdv_from_fragments([symbol(referred_symbol.name)])) source = single_line_source('{string_type} {name} = {symbol_reference}', name=assigned_symbol.name, symbol_reference=referred_symbol) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ assigned_symbol.assert_matches_definition_of_sdv, ]), symbols_after_main=assert_symbol_table_is_singleton( assigned_symbol.name, assigned_symbol.value.assert_matches_container_of_sdv, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def test_ERROR_when_file_does_not_exist__without_explicit_destination__hds(self): for execution_checker in _EXECUTION_CHECKERS: for relativity_option in source_relativity_options__hds(): with self.subTest(parser=execution_checker.name, relativity=relativity_option.test_case_description): execution_checker.value.check( self, args.copy( relativity_option.path_argument_of_rel_name('source-that-do-not-exist') ).as_remaining_source, Arrangement.phase_agnostic( tcds=TcdsArrangement(), symbols=relativity_option.symbols.in_arrangement(), ), Expectation.phase_agnostic_2( validation=ValidationAssertions.pre_sds_fails__w_any_msg(), symbol_usages=relativity_option.symbols.usages_expectation(), ), )
class TestSuccessfulScenarios(unittest.TestCase): def test_successful_parse_of_arbitrary_matcher(self): defined_name = 'defined_name' # ARRANGE # argument_cases = [ NameAndValue('value on same line', '{matcher_argument}' ), NameAndValue('value on following line', '{new_line} {matcher_argument}' ), ] for case in argument_cases: with self.subTest(case.name): source = single_line_source( src2(ValueType.FILES_MATCHER, defined_name, case.value, matcher_argument=arg_syntax.arbitrary_single_line_value_that_must_not_be_quoted()), ) # EXPECTATION # expected_container = matches_container( asrt.equals(ValueType.FILES_MATCHER), type_sdv_assertions.matches_sdv_of_files_matcher() ) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ) ) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def _expect_definition_of( defined_name: str, symbols_for_evaluation: SymbolTable, references: Assertion[Sequence[SymbolReference]], expected_contents: str, may_depend_on_external_resources: bool, ) -> Expectation[None]: sdv_expectation = type_sdv_assertions.matches_sdv( asrt.is_instance(StringSourceSdv), references=references, symbols=symbols_for_evaluation, resolved_value=asrt.anything_goes(), custom=asrt.is_instance_with( StringSourceSdv, str_src_check.execution_assertion( intgr_arr_exp.Arrangement( symbols=symbols_for_evaluation, tcds=TcdsArrangement(), ), primitive=str_src_check.primitive__const( asrt_string_source.pre_post_freeze__matches_str__const( expected_contents, may_depend_on_external_resources=may_depend_on_external_resources ) ) ) ) ) expected_container = matches_container( asrt.equals(ValueType.STRING_SOURCE), sdv_expectation, ) return Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container), ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ) )
def test_successful_parse_and_application_of_non_trivial_matcher(self): defined_name = 'defined_name' expected_container = matches_container( asrt.equals(ValueType.STRING_MATCHER), matches_sdv_of_string_matcher()) not_num_lines_eq_1_matcher_arg = self._not_num_lines_eq_1_matcher_arg() cases = [ NEA('should match', expected=matcher_assertions.is_matching_success(), actual=lines_content([ '1st line', '2nd line', ])), NEA('should not match', expected=matcher_assertions.is_arbitrary_matching_failure(), actual='a single line'), ] for case in cases: source = single_line_source( src2(ValueType.STRING_MATCHER, defined_name, not_num_lines_eq_1_matcher_arg), ) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition( asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, ), instruction_environment=AssertApplicationOfMatcherInSymbolTable( self, defined_name, actual_model_contents=case.actual, expected_matcher_result=case.expected), ) with self.subTest(case.name):