def test_matches(self): command = system_program_command('program', []) stdin_data = () transformer = IdentityStringTransformer() sut.matches_program( command=asrt.is_(command), stdin=asrt.is_(stdin_data), transformer=asrt.matches_singleton_sequence(asrt.is_(transformer)), )
def test_transformation_only_as_source_argument(self): # ARRANGE # transformer = StringTransformerPrimitiveSymbolContext( 'STRING_TRANSFORMER', string_transformers.to_uppercase()) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): program_w_transformer = FullProgramAbsStx( pgm_and_args_case.pgm_and_args, transformation=transformer.abstract_syntax) symbols = list(pgm_and_args_case.symbols) + [transformer] with self.subTest(command=pgm_and_args_case.name): # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_transformer, pgm_and_args_case.mk_arrangement( SymbolContext.symbol_table_of_contexts(symbols)), MultiSourceExpectation( symbol_references=SymbolContext. references_assertion_of_contexts(symbols), primitive=lambda env: (asrt_pgm_val.matches_program( asrt_command. matches_command(driver=pgm_and_args_case. expected_command_driver(env), arguments=asrt.is_empty_sequence), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt.matches_singleton_sequence( asrt.is_(transformer.primitive)), ))))
def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( asrt_command.matches_command( driver=command_driver.expected_command_driver(env), arguments=asrt.equals(all_arguments)), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), )
def expected_program(env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( asrt_command.matches_command( driver=program_ref_case.expected_command_driver(env), arguments=asrt.is_empty_sequence, ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), )
def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( command=asrt_command.equals_shell_command( command_line=shell_command_line_of_referenced_program, arguments=expected_argument_strings, ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), )
def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( command=asrt_command.equals_system_program_command( program=program_case.expected_resolved_value, arguments=argument_case.expected_resolved_values( env.tcds)), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), )
def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( asrt_command.matches_command( driver=pgm_and_args_case.expected_command_driver(env), arguments=asrt.is_empty_sequence), stdin=asrt.matches_singleton_sequence( asrt_str_src.matches__str( asrt.equals(str_src_contents), )), transformer=asrt_pgm_val.is_no_transformation(), )
def expected_program( env: AssertionResolvingEnvironment) -> Assertion[Program]: return asrt_pgm_val.matches_program( command=asrt_command.equals_system_program_command( program=referenced_system_program_name, arguments=referenced_program_arguments + case.expected_additional_arguments, ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), )
def runTest(self): # ARRANGE # transformer = StringTransformerPrimitiveSymbolContext( 'STRING_TRANSFORMER', string_transformers.to_uppercase()) after_bin_op = 'after bin op' after_bin_op_syntax = CustomStringTransformerAbsStx.of_str( after_bin_op) composition_string_transformer = StringTransformerCompositionAbsStx( [transformer.abstract_syntax, after_bin_op_syntax], within_parens=False, allow_elements_on_separate_lines=False, ) expected_source_after_parse = asrt_source.is_at_line( current_line_number=2, remaining_part_of_current_line=' '.join( [composition_string_transformer.operator_name(), after_bin_op]), ) for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference( ): command_followed_by_transformer = FullProgramAbsStx( pgm_and_args_case.pgm_and_args, transformation=composition_string_transformer, ) symbols = list(pgm_and_args_case.symbols) + [transformer] with self.subTest(command=pgm_and_args_case.name): source = remaining_source( command_followed_by_transformer.tokenization().layout( LayoutSpec.of_default())) # ACT & ASSERT # CHECKER_WO_EXECUTION.check( self, source, None, pgm_and_args_case.mk_arrangement( SymbolContext.symbol_table_of_contexts(symbols)), Expectation( ParseExpectation( source=expected_source_after_parse, symbol_references=SymbolContext. references_assertion_of_contexts(symbols), ), primitive=lambda env: (asrt_pgm_val.matches_program( asrt_command. matches_command(driver=pgm_and_args_case. expected_command_driver(env), arguments=asrt.is_empty_sequence), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt.matches_singleton_sequence( asrt.is_(transformer.primitive)), ))))
def runTest(self): # ARRANGE # for pgm_and_args_case in pgm_and_args_cases.cases_w_and_wo_argument_list__including_program_reference(): with self.subTest(command=pgm_and_args_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_and_args_case.pgm_and_args, pgm_and_args_case.mk_arrangement(SymbolContext.symbol_table_of_contexts(pgm_and_args_case.symbols)), MultiSourceExpectation( symbol_references=SymbolContext.references_assertion_of_contexts(pgm_and_args_case.symbols), primitive=lambda env: ( asrt_pgm_val.matches_program( asrt_command.matches_command( driver=pgm_and_args_case.expected_command_driver(env), arguments=asrt.is_empty_sequence ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), ) ) ) )
def test_not_matches(self): expected_command = system_program_command('program', []) expected_stdin = [string_sources.string_source_that_must_not_be_used()] expected_transformer = IdentityStringTransformer() assertion = sut.matches_program( command=asrt.is_(expected_command), stdin=asrt.len_equals(len(expected_stdin)), transformer=asrt.matches_singleton_sequence( asrt.is_(expected_transformer)), ) actual_command = system_program_command('program', []) actual_stdin = () actual_transformer = () cases = [ NameAndValue( 'unexpected command', Program(command=actual_command, stdin=expected_stdin, transformation=[expected_transformer])), NameAndValue( 'unexpected stdin', Program(command=expected_command, stdin=actual_stdin, transformation=[expected_transformer])), NameAndValue( 'unexpected transformer', Program(command=expected_command, stdin=expected_stdin, transformation=actual_transformer)), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(assertion, case.value)
def test_stdin_in_referenced_program_and_as_source_argument(self): # ARRANGE # str_src_contents__of_argument = 'the_str_src_contents__of_argument' str_src_contents__of_referenced_pgm = 'the_str_src_contents__of_program' stdin_argument_syntax = str_src_abs_stx.StringSourceOfStringAbsStx.of_str( str_src_contents__of_argument) stdin_sdv__of_referenced = str_src_sdvs.ConstantStringStringSourceSdv( string_sdvs.str_constant(str_src_contents__of_referenced_pgm)) referenced_program__system_program = 'the-system-program' referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant(referenced_program__system_program), stdin=[stdin_sdv__of_referenced], ) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) symbols__symbol_table = [referenced_program] symbols__expected_references = [referenced_program] arguments_cases = [ NameAndValue( 'no arguments', [], ), NameAndValue( 'single argument', ['arg1'], ) ] for arguments_case in arguments_cases: with self.subTest(arguments=arguments_case.name): program_w_stdin = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, [ ArgumentOfRichStringAbsStx.of_str(arg) for arg in arguments_case.value ]), stdin=stdin_argument_syntax, ) expected_primitive = asrt_pgm_val.matches_program( asrt_command.matches_command( driver=asrt_command. matches_system_program_command_driver( asrt.equals(referenced_program__system_program)), arguments=asrt.equals(arguments_case.value), ), stdin=asrt.matches_sequence([ asrt_str_src.matches__str( asrt.equals(str_src_contents__of_referenced_pgm)), asrt_str_src.matches__str( asrt.equals(str_src_contents__of_argument)), ]), transformer=asrt_pgm_val.is_no_transformation(), ) # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_stdin, arrangement_w_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__symbol_table), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), primitive=expected_primitive, ))
def test_list_of_arguments_and_symbol_references(self): arg_wo_space = 'arg_wo_space' arg_w_space = 'an arg w space' string_symbol_1 = StringConstantSymbolContext( 'STRING_SYMBOL_1', 'value of string symbol 1', default_restrictions=asrt_data_rest.is__w_str_rendering(), ) string_symbol_2 = StringConstantSymbolContext( 'STRING_SYMBOL_2', 'value of string symbol 2', default_restrictions=asrt_data_rest.is__w_str_rendering(), ) arguments_cases = [ ArgumentsCase( 'one / wo symbol references', arguments=[ ArgumentOfRichStringAbsStx.of_str(arg_w_space, QuoteType.SOFT) ], expected_arguments=[arg_w_space], symbols=(), ), ArgumentsCase( 'two / wo symbol references', arguments=[ ArgumentOfRichStringAbsStx.of_str(arg_wo_space), ArgumentOfRichStringAbsStx.of_str(arg_w_space, QuoteType.HARD) ], expected_arguments=[arg_wo_space, arg_w_space], symbols=(), ), ArgumentsCase( 'three / w symbol references', arguments=[ ArgumentOfSymbolReferenceAbsStx(string_symbol_1.name), ArgumentOfRichStringAbsStx.of_str(arg_w_space, QuoteType.HARD), ArgumentOfSymbolReferenceAbsStx(string_symbol_2.name) ], expected_arguments=[ string_symbol_1.str_value, arg_w_space, string_symbol_2.str_value ], symbols=[string_symbol_1, string_symbol_2], ), ] # ARRANGE # 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.arguments) expected_arguments = asrt.equals( arguments_case.expected_arguments) symbols = list(pgm_and_args_case.symbols) + list( arguments_case.symbols) expectation = MultiSourceExpectation( symbol_references=SymbolContext. references_assertion_of_contexts(symbols), primitive=lambda env: (asrt_pgm_val.matches_program( asrt_command.matches_command( driver=pgm_and_args_case.expected_command_driver( env), arguments=expected_arguments, ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt_pgm_val.is_no_transformation(), ))) with self.subTest(command=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, pgm_and_args_case.mk_arrangement( SymbolContext.symbol_table_of_contexts(symbols)), expectation, )
def test_transformation_in_referenced_program_and_as_source_argument(self): # ARRANGE # transformer__in_referenced_program = StringTransformerPrimitiveSymbolContext( 'TRANSFORMER_IN_REFERENCED_PROGRAM', string_transformers.delete_everything()) referenced_program__system_program = 'the-system-program' referenced_program__sdv = program_sdvs.system_program( string_sdvs.str_constant(referenced_program__system_program), transformations=[transformer__in_referenced_program.reference_sdv]) referenced_program = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', referenced_program__sdv) transformer__in_source = StringTransformerPrimitiveSymbolContext( 'TRANSFORMER_IN_SOURCE', string_transformers.to_uppercase()) symbols__symbol_table = [ referenced_program, transformer__in_referenced_program, transformer__in_source ] symbols__expected_references = [ referenced_program, transformer__in_source ] arguments_cases = [ NameAndValue( 'no arguments', [], ), NameAndValue( 'single argument', ['arg1'], ) ] for arguments_case in arguments_cases: with self.subTest(arguments=arguments_case.name): program_w_transformer = FullProgramAbsStx( ProgramOfSymbolReferenceAbsStx(referenced_program.name, [ ArgumentOfRichStringAbsStx.of_str(arg) for arg in arguments_case.value ]), transformation=transformer__in_source.abstract_syntax) expected_primitive = asrt_pgm_val.matches_program( asrt_command.matches_command( driver=asrt_command. matches_system_program_command_driver( asrt.equals(referenced_program__system_program)), arguments=asrt.equals(arguments_case.value), ), stdin=asrt_pgm_val.is_no_stdin(), transformer=asrt.matches_sequence([ asrt.is_(transformer__in_referenced_program.primitive), asrt.is_(transformer__in_source.primitive), ]), ) # ACT & ASSERT # CHECKER_WO_EXECUTION.check__abs_stx__layouts__source_variants__wo_input( self, equivalent_source_variants__for_expr_parse__s__nsc, program_w_transformer, arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts( symbols__symbol_table), ), MultiSourceExpectation.of_const( symbol_references=SymbolContext. references_assertion_of_contexts( symbols__expected_references), primitive=expected_primitive, ))