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_main_method_arguments(self): # ARRANGE # the_environ = MappingProxyType({'the_env_var': 'the env var value'}) the_timeout = 69 the_os_services = os_services_access.new_for_current_os() def main_action_that_checks_arguments(environment: InstructionEnvironmentForPostSdsStep, instruction_settings: InstructionSettings, os_services: OsServices): self.assertIs(os_services, the_os_services, 'os_services') self.assertEqual(the_environ, environment.proc_exe_settings.environ, 'proc exe settings/environment') self.assertEqual(the_timeout, environment.proc_exe_settings.timeout_in_seconds, 'proc exe settings/timeout') self.assertEqual(the_environ, instruction_settings.environ(), 'instruction settings/environment') # ACT & ASSERT # self._check_source_and_exe_variants( ParserThatGives(instruction_embryo_that__phase_agnostic( main_initial_action=main_action_that_checks_arguments )), Arrangement.phase_agnostic( process_execution_settings=ProcessExecutionSettings(the_timeout, the_environ), os_services=the_os_services, ), MultiSourceExpectation.phase_agnostic(), )
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_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_source(self): self._check( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, single_line_source(), Arrangement.phase_agnostic(), Expectation.phase_agnostic(source=asrt.IsInstance(ParseSource)), )
def test_assignment_of_list_with_symbol_references(self): # ARRANGE # referred_symbol_name = 'referred_symbol' expected_symbol_reference = references.reference_to__w_str_rendering( referred_symbol_name) symbol_to_assign = ListSymbolContext.of_sdv( 'the_symbol_name', sdvs.from_elements( [sdvs.symbol_element(expected_symbol_reference)])) syntax = _syntax(symbol_to_assign, ListSymbolReferenceAbsStx(referred_symbol_name)) # ACT & ASSERT # INSTRUCTION_CHECKER.check__abs_stx__layout_and_source_variants( self, syntax, Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( symbol_usages=asrt.matches_sequence( [symbol_to_assign.assert_matches_definition_of_sdv]), symbols_after_main=assert_symbol_table_is_singleton( symbol_to_assign.name, symbol_to_assign.value.assert_matches_container_of_sdv, ), ), )
def runTest(self): string_72_plus = StringSymbolContext.of_constant( 'SYMBOL_72_PLUS', '72+', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) string_5 = StringSymbolContext.of_constant( 'SYMBOL_5', '5', default_restrictions=asrt_data_rest. is__string__w_all_indirect_refs_are_strings(), ) expected = 72 + 5 all_symbols = [string_72_plus, string_5] value_syntax = StringConcatAbsStx([ string_72_plus.abstract_syntax, string_5.abstract_syntax, ]) CHECKER.check__abs_stx__layout_and_source_variants( self, InstructionArgumentsAbsStx.of_int(value_syntax), Arrangement.phase_agnostic( symbols=SymbolContext.symbol_table_of_contexts(all_symbols), ), MultiSourceExpectation.phase_agnostic( symbol_usages=SymbolContext.usages_assertion_of_contexts( all_symbols), instruction_settings=asrt_instr_settings.matches( timeout=asrt.equals(expected))), )
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_copy_file__destination_is_existing_directory(self): # ARRANGE # src = 'src-file' dst = 'dst-dir' file_to_install = File(src, 'contents') home_dir_contents = [file_to_install] act_dir_contents = [Dir.empty(dst)] act_dir_contents_after = [Dir(dst, [file_to_install])] for parser_case in _EXECUTION_CHECKERS: with self.subTest(parser=parser_case.name): # ACT & ASSERT # parser_case.value.check__w_source_variants( 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_str, 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( DirContents(home_dir_contents) ), sds_contents=defs.DEFAULT_DST_REL_OPT.populator_for_relativity_option_root__sds( DirContents(act_dir_contents) ), ), ), MultiSourceExpectation.phase_agnostic( main_side_effects_on_sds=sds_contents_check.cwd_contains_exactly( DirContents(act_dir_contents_after)) ), )
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_reference_to_string_source(self): # ARRANGE # defined_name = symbol_syntax.A_VALID_SYMBOL_NAME referenced_symbol = StringSourceSymbolContextOfPrimitiveConstant('referenced_name', 'contents of string source') syntax = _syntax_of( referenced_symbol.abstract_syntax, defined_name, ) arrangement = Arrangement.phase_agnostic() # EXPECTATION # expectation = _expect_definition_of( defined_name, referenced_symbol.symbol_table, referenced_symbol.references_assertion, referenced_symbol.contents_str, may_depend_on_external_resources=False ) # ACT & ASSERT # INSTRUCTION_CHECKER.check__abs_stx__std_layouts_and_source_variants( self, syntax, arrangement, expectation, )
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 test_contents_from_here_doc(self): # ARRANGE # string_value = rich_str_abs_stx.HereDocAbsStx( 'single line in here doc\n') expected_file = fs.File('a-file-name.txt', string_value.value) rel_opt_conf = ARBITRARY_ALLOWED_DST_FILE_RELATIVITY dst_path = rel_opt_conf.path_abs_stx_of_name(expected_file.name) instruction_syntax = instr_abs_stx.create_w_explicit_contents( dst_path, string_source_abs_stx.StringSourceOfStringAbsStx(string_value), ) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest(phase_is_after_act=phase_is_after_act): # 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, ), ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, side_effects_on_hds=f_asrt.dir_is_empty(), symbol_usages=asrt.is_empty_sequence, main_side_effects_on_sds=non_hds_dir_contains_exactly( rel_opt_conf.root_dir__non_hds, fs.DirContents([expected_file])), ))
def test_WHEN_program_is_non_non_existing_system_command_THEN_result_SHOULD_be_error_message(self): failing_program_builder = program_abs_stx.TransformableProgramAbsStxBuilder( program_abs_stx.ProgramOfSystemCommandLineAbsStx.of_str(NON_EXISTING_SYSTEM_PROGRAM) ) transformer = TO_UPPER_TRANSFORMER_SYMBOL symbols = transformer.symbol_table cases = failing_program_builder.with_and_without_transformer_cases(transformer.abstract_syntax) for transformation_case in cases: instruction_syntax = instr_abs_stx.create_w_explicit_contents( path_abs_stx.DefaultRelPathAbsStx('dst-file'), string_source_abs_stx.StringSourceOfProgramAbsStx( ProcOutputFile.STDOUT, transformation_case.value, ignore_exit_code=False) ) for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) with self.subTest(phase_is_after_act=phase_is_after_act, transformation=transformation_case.name): checker.check__abs_stx__std_layouts_and_source_variants( self, instruction_syntax, Arrangement.phase_agnostic( symbols=symbols, tcds=TcdsArrangement(), ), MultiSourceExpectation.phase_agnostic( symbol_usages=asrt.anything_goes(), main_result=IS_FAILURE, ) )
def test_single_file_in_root_dir(self): # ARRANGE # expected_file = File.empty('file-name.txt') for phase_is_after_act in [False, True]: checker = integration_check.checker(phase_is_after_act) for rel_opt_conf in ALLOWED_DST_FILE_RELATIVITIES: with self.subTest( relativity_option_string=rel_opt_conf.option_argument, phase_is_after_act=phase_is_after_act): instruction_syntax = abs_stx.without_contents( rel_opt_conf.path_abs_stx_of_name(expected_file.name)) # 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, ), ), MultiSourceExpectation.phase_agnostic( main_result=IS_SUCCESS, side_effects_on_hds=f_asrt.dir_is_empty(), symbol_usages=asrt.is_empty_sequence, main_side_effects_on_sds= non_hds_dir_contains_exactly( rel_opt_conf.root_dir__non_hds, fs.DirContents([expected_file])), ))
def test_with_explicit_non_cd_relativity_and_source_layout_variants(self): # ARRANGE # relativity = RelOptionType.REL_TMP for is_after_act_phase in [False, True]: checker = embryo_checker(is_after_act_phase) for case in path_name_variants.SOURCE_LAYOUT_CASES: path_argument = RelOptPathArgument(case.input_value, relativity) with self.subTest(case.name, is_after_act_phase=is_after_act_phase): with self.subTest(case.name): # ACT & ASSERT # checker.check__w_source_variants( self, path_argument.as_str, Arrangement.phase_agnostic(tcds=TcdsArrangement( tcds_contents=tcds_populators. TcdsPopulatorForRelOptionType( relativity, DirContents( [Dir.empty(case.expected_value)]))), ), MultiSourceExpectation.phase_agnostic( side_effects_on_tcds=CwdAssertion( relativity, case.expected_value, )))
def test_assignment_of_list_with_multiple_constant_elements(self): # ARRANGE # value_without_space = 'value_without_space' value_with_space = 'value with space' symbol_to_assign = ListSymbolContext.of_sdv( 'the_symbol_name', sdvs.from_str_constants([value_without_space, value_with_space])) syntax = _syntax( symbol_to_assign, NonEmptyListAbsStx([ ListElementStringAbsStx.of_str(value_without_space), ListElementStringAbsStx.of_str(value_with_space, QuoteType.SOFT), ])) expectation = MultiSourceExpectation.phase_agnostic( symbol_usages=asrt.matches_sequence( [symbol_to_assign.assert_matches_definition_of_sdv]), symbols_after_main=assert_symbol_table_is_singleton( symbol_to_assign.name, symbol_to_assign.value.assert_matches_container_of_sdv, ), ) # ACT & ASSERT # INSTRUCTION_CHECKER.check__abs_stx__layout_and_source_variants( self, syntax, Arrangement.phase_agnostic(), expectation, )
def test_validate_should_fail_when_executable_does_not_exist(self): existing_file_to_interpret = 'existing-file-to-interpret.src' home_dir_contents = fs.DirContents( [File.empty(existing_file_to_interpret)]) for relativity_option_conf in RELATIVITY_OPTIONS: argument = '{relativity_option} non-existing-file {interpret_option}' \ ' {rel_hds_case_option} {existing_file}'.format( relativity_option=relativity_option_conf.option_argument, interpret_option=syntax_elements.EXISTING_FILE_OPTION_NAME, rel_hds_case_option=REL_HDS_CASE_OPTION, existing_file=existing_file_to_interpret, ) expectation = _expect_validation_error_and_symbol_usages_of( relativity_option_conf) arrangement = Arrangement.phase_agnostic( symbols=relativity_option_conf.symbols.in_arrangement(), tcds=TcdsArrangement( hds_contents=hds_case_dir_contents(home_dir_contents), ), ) with self.subTest(msg='option=' + relativity_option_conf.test_case_description): EXECUTION_CHECKER.check__w_source_variants( self, argument, arrangement, 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_check_non_zero_exit_code(self): EXECUTION_CHECKER.check__w_source_variants( self, pgm_args.interpret_py_source_line('exit(1)').as_str, Arrangement.phase_agnostic(tcds=TcdsArrangement(), ), MultiSourceExpectation.phase_agnostic( main_result=result_assertions.equals(1, '')))
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_success_when_executable_does_exist(self): for relativity_option_conf in RELATIVITY_OPTIONS: argument = '{relativity_option} {executable_file}'.format( relativity_option=relativity_option_conf.option_argument, executable_file=EXECUTABLE_FILE_THAT_EXITS_WITH_CODE_0. file_name, ) expectation = MultiSourceExpectation.phase_agnostic( symbol_usages=asrt.matches_sequence( relativity_option_conf.symbols. usage_expectation_assertions()), ) arrangement = Arrangement.phase_agnostic( tcds=TcdsArrangement( tcds_contents=relativity_option_conf. populator_for_relativity_option_root( fs.DirContents( [EXECUTABLE_FILE_THAT_EXITS_WITH_CODE_0])), ), symbols=relativity_option_conf.symbols.in_arrangement(), ) with self.subTest( option=relativity_option_conf.test_case_description): EXECUTION_CHECKER.check__w_source_variants( self, argument, arrangement, expectation)
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_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 runTest(self): # ARRANGE # cases = [ NameAndValue( 'pre sds', ( RelOptionType.REL_HDS_CASE, ValidationAssertions.pre_sds_fails__w_any_msg(), ), ), NameAndValue( 'post sds', ( RelOptionType.REL_ACT, ValidationAssertions.post_sds_fails__w_any_msg(), ), ), ] for case in cases: with self.subTest(case.name): CHECKER.check__w_source_variants( self, command_line( 'program', program_arguments.existing_path( path_arguments.RelOptPathArgument('name', case.value[0]), ) ).as_str, Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( validation=case.value[1], ), )
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_fail_due_to_assertion_on_instruction_environment(self): self._check_source_and_exe_variants__failing_assertions( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( instruction_environment=asrt.fail('unconditional failure') ), )
def test_fail_due_to_fail_of_side_effects_on_instruction_settings(self): self._check_source_and_exe_variants__failing_assertions( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, Arrangement.phase_agnostic(), MultiSourceExpectation.phase_agnostic( instruction_settings=asrt.not_(asrt.is_instance(InstructionSettings)), ), )