def test_not_equals(self): string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value') cases = [ Case('different number of elements', expected= list_sdvs.empty(), actual= list_sdvs.from_str_constants(['value']), ), Case('different value of single string', expected= list_sdvs.from_str_constants(['expected value']), actual= list_sdvs.from_str_constants(['actual value']), ), Case('different element types, but same resolved value', expected= list_sdvs.from_str_constants([string_symbol.str_value]), actual= list_sdvs.from_elements([list_sdvs.symbol_element(string_symbol.reference__w_str_rendering)]), symbols= string_symbol.symbol_table, ), ] for case in cases: with self.subTest(msg=case.name): assertion = sut.equals_list_sdv(case.expected, case.symbols) assert_that_assertion_fails(assertion, case.actual)
def _check( self, command_driver: CommandDriverSdvCase, arguments_of_referenced_command: List[str], accumulated_arguments_of_referenced_program: List[str], additional_argument: List[str], ): # ARRANGE # all_arguments = (arguments_of_referenced_command + accumulated_arguments_of_referenced_program + additional_argument) 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(), ) referenced_program_symbol = ProgramSymbolContext.of_sdv( 'REFERENCED_PROGRAM', command_program_sdv.ProgramSdvForCommand( CommandSdv( command_driver.command_driver, ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants( arguments_of_referenced_command))), AccumulatedComponents.of_arguments( ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants( accumulated_arguments_of_referenced_program))))) source_to_parse = self.source_to_parse( referenced_program_symbol.name, [ ArgumentOfRichStringAbsStx.of_str(arg) for arg in additional_argument ], ) # ACT & ASSERT # self.integration_checker().check__abs_stx__wo_input( self.put, source_to_parse, command_driver.mk_arrangement( referenced_program_symbol.symbol_table), Expectation( parse=ParseExpectation( symbol_references=referenced_program_symbol. references_assertion, ), primitive=expected_program, ), )
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 of_constants( elements: Sequence[str], definition_source: Optional[ SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION, ) -> 'ListSymbolValueContext': return ListSymbolValueContext.of_sdv( list_sdvs.from_str_constants(elements), definition_source)
def for_system_program__from_pgm_and_args( pgm_and_args: ProgramAndArguments) -> CommandSdv: program = string_sdvs.str_constant(pgm_and_args.program) arguments = list_sdvs.from_str_constants(pgm_and_args.arguments) additional_arguments = ArgumentsSdv.new_without_validation(arguments) return for_system_program(program).new_with_additional_arguments( additional_arguments)
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 _command_to_execute( self, environment: InstructionEnvironmentForPostSdsStep, ) -> CommandSdv: return self.object_to_execute.interpreter.new_with_additional_arguments( ArgumentsSdv( list_sdvs.from_str_constants([str(self.source_file_path)])))
def test_equals(self): cases = [ list_sdvs.from_str_constants(['value']), list_sdvs.from_elements([list_sdvs.symbol_element(reference_to__on_direct_and_indirect('symbol_name'))]), ] for sdv in cases: with self.subTest(msg=str(sdv)): sut.equals_list_sdv(sdv).apply_without_message(self, sdv)
def _source_interpreter_with_system_command( cmd_and_args: List[str]) -> NameAndValue[Actor]: command_sdv = command_sdvs.for_system_program( string_sdvs.str_constant(cmd_and_args[0]), ArgumentsSdv(list_sdvs.from_str_constants(cmd_and_args[1:])), ) return NameAndValue(actors.SOURCE_INTERPRETER_ACTOR.singular_name, actor.actor(command_sdv))
def test_not_equals__list(self): # ARRANGE # expected = list_sdvs.from_str_constants(['value']) actual = list_sdvs.from_elements([ list_sdvs.symbol_element( data_references.reference_to__on_direct_and_indirect( 'symbol_name')) ]) # ACT & ASSERT # assert_that_assertion_fails(sut.equals_data_type_sdv(expected), actual)
def test_list_constant(self): # ARRANGE # constant = ['a', 'b' 'c'] # ACT # actual = list_sdvs.from_str_constants(constant) # ASSERT # self.assertEqual([], actual.references, 'references') actual_value = actual.resolve(empty_symbol_table()) expected_value = AMultiDirDependentValue(resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return(constant), get_value_of_any_dependency=do_return(constant)) matches_multi_dir_dependent_value(expected_value).apply_with_message(self, actual_value, 'resolve value')
def test_not_equals(self): string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value') cases = [ MatchesCase('different number of elements', expected= lr.ListDdv([]), expected_references= asrt.is_empty_sequence, actual= list_sdvs.from_str_constants(['value']), ), MatchesCase('different value of single string', expected= lr.ListDdv([string_ddv_of_single_string('expected value')]), expected_references= asrt.is_empty_sequence, actual= list_sdvs.from_str_constants(['actual value']), ), MatchesCase('different references', expected= lr.ListDdv([string_ddv_of_single_string(string_symbol.str_value)]), expected_references= asrt.matches_sequence([string_symbol.reference_assertion__w_str_rendering]), actual= list_sdvs.from_elements([list_sdvs.string_element( string_sdvs.symbol_reference( SymbolReference(string_symbol.name, OrReferenceRestrictions([])), ))]), symbols= string_symbol.symbol_table, ), ] for case in cases: with self.subTest(msg=case.name): assertion = sut.matches_list_sdv(case.expected, case.expected_references, case.symbols) assert_that_assertion_fails(assertion, case.actual)
def test_equals(self): test_cases = [ ( list_sdvs.empty(), [] ), ( list_sdvs.from_str_constants(['value 1', 'value 2']), ['value 1', 'value 2'] ), ] for actual, expected in test_cases: with self.subTest(expected=repr(expected)): sut.equals_constant_list(expected).apply_without_message(self, actual)
def test_not_equals(self): test_cases = [ ( list_sdvs.empty(), ['non empty'] ), ( list_sdvs.from_str_constants(['value 1', 'value 2 actual']), ['value 1', 'value 2 expected'] ), ] for actual, expected in test_cases: assertion = sut.equals_constant_list(expected) with self.subTest(expected=repr(expected)): assert_that_assertion_fails(assertion, actual)
def test_equals(self): string_symbol = StringConstantSymbolContext('string_symbol_name', 'string symbol value') cases = [ MatchesCase('empty list of fragments', expected= lr.ListDdv([]), expected_references= asrt.is_empty_sequence, actual= list_sdvs.empty(), ), MatchesCase('single fragment', expected= lr.ListDdv([string_ddv_of_single_string('expected value')]), expected_references= asrt.is_empty_sequence, actual= list_sdvs.from_str_constants(['expected value']), ), MatchesCase('symbol reference', expected= lr.ListDdv([string_ddv_of_single_string(string_symbol.str_value)]), expected_references= asrt.matches_sequence([string_symbol.reference_assertion__w_str_rendering]), actual= list_sdvs.from_elements([list_sdvs.string_element( string_sdvs.symbol_reference(string_symbol.reference__w_str_rendering) )]), symbols= string_symbol.symbol_table, ), ] for case in cases: with self.subTest(msg=case.name): assertion = sut.matches_list_sdv(case.expected, case.expected_references, case.symbols) assertion.apply_without_message(self, case.actual)
def equals_constant_list(expected_str_list: Iterable[str]) -> Assertion[SymbolDependentValue]: return equals_list_sdv(list_sdvs.from_str_constants(expected_str_list))
def test_equals__list(self): # ARRANGE # value = list_sdvs.from_str_constants(['value']) # ACT & ASSERT # sut.equals_data_type_sdv(value).apply_without_message(self, value)
def test_shell_program_via_symbol_reference(self): shell_command_line_of_referenced_program = 'initial shell command line' arguments_of_referenced_program = ['arg1', 'arg 2'] referenced_shell_program_sdv = program_sdvs.shell_program( string_sdvs.str_constant(shell_command_line_of_referenced_program), ArgumentsSdv.new_without_validation( list_sdvs.from_str_constants(arguments_of_referenced_program)), ) referenced_program_symbol = ProgramSymbolContext.of_sdv( 'SHELL_PROGRAM_REFERENCE', referenced_shell_program_sdv, ) string_argument_symbol = StringConstantSymbolContext( 'STRING_ARGUMENT_SYMBOL', 'string argument', ) list_argument_symbol = ListConstantSymbolContext( 'LIST_ARGUMENT_SYMBOL', ['list_arg_value_1', 'list arg value 2']) str_w_list_template = 'before{}after' str_w_list_ref = str_w_list_template.format( list_argument_symbol.name__sym_ref_syntax) expected_argument_strings = ( arguments_of_referenced_program + [string_argument_symbol.str_value] + list_argument_symbol.constant_list + [ str_w_list_template.format(' '.join( list_argument_symbol.constant_list)) ]) symbols = [ referenced_program_symbol, string_argument_symbol, list_argument_symbol ] syntax = ProgramOfSymbolReferenceAbsStx( referenced_program_symbol.name, [ ArgumentOfSymbolReferenceAbsStx(string_argument_symbol.name), ArgumentOfSymbolReferenceAbsStx(list_argument_symbol.name), ArgumentOfRichStringAbsStx.of_str(str_w_list_ref), ]) 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(), ) expectation = MultiSourceExpectation( symbol_references=asrt.matches_sequence([ referenced_program_symbol.reference_assertion, string_argument_symbol.reference_assertion__w_str_rendering, list_argument_symbol.reference_assertion__w_str_rendering, list_argument_symbol.reference_assertion__w_str_rendering, ]), primitive=expected_program, ) # 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, syntax, arrangement_wo_tcds( symbols=SymbolContext.symbol_table_of_contexts(symbols), ), expectation, )