def test_matches(self): accessor_error = sut.AccessorError( sut.AccessErrorType.PRE_PROCESS_ERROR, self._ERROR_INFO_WITH_DESCRIPTION) cases = [ NEA( 'default', actual=accessor_error, expected=sut.accessor_error_matches(), ), NEA( 'error', actual=accessor_error, expected=sut.accessor_error_matches( error=asrt.is_(accessor_error.error)), ), NEA( 'error_info', actual=accessor_error, expected=sut.accessor_error_matches( error_info=asrt.is_(accessor_error.error_info)), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def test(self): # ARRANGE # detail = sut.StringDetail('a detail') child = sut.Node('child header', False, (), ()) root_header = 'root header' root_data = True root = sut.Node(root_header, root_data, (detail,), (child,)) # ACT & ASSERT # self.assertEqual(root_header, root.header, 'root header') self.assertEqual(root_data, root.data, 'root data') expected_root_details = asrt.matches_singleton_sequence( asrt.is_(detail) ) expected_root_details.apply_with_message(self, root.details, 'root details') expected_root_children = asrt.matches_singleton_sequence( asrt.is_(child) ) expected_root_children.apply_with_message(self, root.children, 'root children')
def test_not_matches(self): # ARRANGE # expected_instruction = Instruction() expected_description = 'the description' instruction_info = InstructionInfo(expected_instruction, expected_description) expected_source = LineSequence(1, ('expected',)) actual_element = ParsedInstruction(expected_source, instruction_info) cases = [ NameAndValue('mismatch on source', sut.matches_instruction(asrt.not_(equals_line_sequence(expected_source)), matches_instruction_info(asrt.equals(expected_description), asrt.is_(expected_instruction))) ), NameAndValue('mismatch on description', sut.matches_instruction(equals_line_sequence(expected_source), matches_instruction_info(asrt.not_(asrt.equals(expected_description)), asrt.is_(expected_instruction))) ), NameAndValue('mismatch on instruction', sut.matches_instruction(equals_line_sequence(expected_source), matches_instruction_info(asrt.not_(asrt.equals(expected_description)), asrt.not_(asrt.is_(expected_instruction)))) ), ] for nav in cases: with self.subTest(nav.name): # ACT & ASSERT # assert_that_assertion_fails(nav.value, actual_element)
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_matches(self): command = system_program_command('program', []) stdin_data = StdinData([]) transformer = IdentityStringTransformer() sut.matches_program( command=asrt.is_(command), stdin=asrt.is_(stdin_data), transformer=asrt.is_(transformer), )
def test_success(self): # ARRANGE # reference = data_symbol_utils.symbol_reference('symbol_name') string_resolver = _StringResolverTestImpl(resolve_constant(STRING_VALUE), [reference]) assertion = sut.matches_resolver(sut.is_resolver_of_string_type(), asrt.len_equals(1), asrt.is_(STRING_VALUE), asrt.is_(string_resolver)) # ACT & ASSERT # assertion.apply_without_message(self, string_resolver)
def test_success(self): # ARRANGE # path_symbol = PathDdvSymbolContext( 'symbol_name', path_ddvs.of_rel_option(RelOptionType.REL_ACT)) reference = data_references.reference_to__on_direct_and_indirect( path_symbol.name) path_sdv = PathSdvTestImplWithConstantPathAndSymbolReferences( path_symbol.ddv, [reference]) assertion = sut.matches_sdv(asrt.is_instance(PathSdv), asrt.len_equals(1), asrt.is_(path_symbol.ddv), asrt.is_(path_sdv), symbols=path_symbol.symbol_table) # ACT & ASSERT # assertion.apply_without_message(self, path_sdv)
def equals_container( expected: SymbolContainer, ignore_source_line: bool = True) -> Assertion[SymbolContainer]: """ :param expected: Must contain a data type value """ component_assertions = [ asrt.sub_component('value_type', SymbolContainer.value_type.fget, asrt.is_(expected.value_type)), ] if not ignore_source_line: component_assertions.append( asrt.sub_component( 'definition_source', SymbolContainer.definition_source.fget, equals_line_sequence(expected.definition_source))) component_assertions.append( asrt.sub_component( 'source_location', SymbolContainer.source_location.fget, asrt.is_none_or_instance_with( SourceLocationInfo, asrt_src_loc.is_valid_source_location_info())), ) expected_sdv = expected.sdv assert isinstance(expected_sdv, DataTypeSdv), 'All actual values must be DataTypeSdv' component_assertions.append( asrt.sub_component('sdv', SymbolContainer.sdv.fget, equals_data_type_sdv(expected_sdv))) return asrt.is_instance_with(SymbolContainer, asrt.and_(component_assertions))
def is_resolver_of_data_type(data_value_type: DataValueType, value_type: ValueType) -> ValueAssertion[rs.SymbolValueResolver]: return asrt.is_instance_with(DataValueResolver, asrt.and_([ asrt.sub_component('type_category', rs.get_type_category, asrt.is_(TypeCategory.DATA)), asrt.sub_component('data_value_type', get_data_value_type, asrt.is_(data_value_type)), asrt.sub_component('value_type', rs.get_value_type, asrt.is_(value_type)), ]))
def is_resolver_of_logic_type(logic_value_type: LogicValueType, value_type: ValueType) -> ValueAssertion[rs.SymbolValueResolver]: return asrt.is_instance_with(LogicValueResolver, asrt.and_([ asrt.sub_component('type_category', rs.get_type_category, asrt.is_(TypeCategory.LOGIC)), asrt.sub_component('logic_value_type', get_logic_value_type, asrt.is_(logic_value_type)), asrt.sub_component('value_type', rs.get_value_type, asrt.is_(value_type)), ]))
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 is_skipped() -> Assertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.SKIPPED), failure_info=asrt.is_none, has_sds=asrt.equals(False), sds=asrt.is_none, has_action_to_check_outcome=asrt.equals(False), action_to_check_outcome=asrt.is_none)
def is_skipped() -> ValueAssertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.SKIPPED), failure_info=asrt.is_none, has_sds=asrt.equals(False), sds=asrt.is_none, has_action_to_check_outcome=asrt.equals(False), action_to_check_outcome=asrt.is_none)
def test_element_from_instruction_parser_SHOULD_be_assigned_to_section_contents_element(self): expected_instruction_info = InstructionInfo(Instruction(), 'description') expected = sut.ParsedInstruction(line_source.LineSequence(1, ('first line text',)), expected_instruction_info) parser = sut.standard_syntax_element_parser(_InstructionParserThatGivesConstant(expected)) source = _source_for_lines(['ignored', 'source', 'lines']) # ACT # element = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # element_assertion = matches_instruction( source=asrt.is_(expected.source), instruction_info=matches_instruction_info( assertion_on_description=asrt.is_(expected_instruction_info.description), assertion_on_instruction=asrt.is_(expected_instruction_info.instruction))) element_assertion.apply_with_message(self, element, 'element')
def test_fail_due_to_unexpected_resolved_value(self): # ARRANGE # string_resolver = _StringResolverTestImpl(resolve_constant(STRING_VALUE)) assertion = sut.matches_resolver(asrt.anything_goes(), asrt.anything_goes(), asrt.not_(asrt.is_(STRING_VALUE))) # ACT & ASSERT # test_of_test_resources_util.assert_that_assertion_fails(assertion, string_resolver)
def is_value_type_restriction(expected: ValueType) -> ValueAssertion[ReferenceRestrictions]: """ Assertion on a :class:`ReferenceRestrictions`, that it is a :class:`TypeCategoryRestriction`, with a given :class:`TypeCategory`. """ expected_type_category = value_type.VALUE_TYPE_2_TYPE_CATEGORY[expected] return asrt.is_instance_with(ValueTypeRestriction, asrt.and_([ asrt.sub_component('value_type', ValueTypeRestriction.value_type.fget, asrt.is_(expected)), asrt.sub_component('type_category', ValueTypeRestriction.type_category.fget, asrt.is_(expected_type_category)), ]), )
def test_fail_due_to_unexpected_resolved_value(self): # ARRANGE # string_sdv = _StringSdvTestImpl(resolve_constant(STRING_DDV)) assertion = sut.matches_sdv(asrt.anything_goes(), asrt.anything_goes(), asrt.not_(asrt.is_(STRING_DDV))) # ACT & ASSERT # test_of_test_resources_util.assert_that_assertion_fails( assertion, string_sdv)
def test_accept_visitor_invokes_correct_method(self): # ARRANGE # operand1 = constant.MatcherWithConstantResult(False) operand2 = constant.MatcherWithConstantResult(False) matcher = sut.Disjunction([operand1, operand2]) return_value = 11 visitor = MatcherStdTypeVisitorTestAcceptImpl.new_w_default_to_raise_exception( disjunction_action=assert_argument_satisfies__and_return( self, asrt.matches_sequence([asrt.is_(operand1), asrt.is_(operand2)]), return_value, )) actual_return_value = matcher.accept(visitor) # ASSERT # self.assertEqual(return_value, actual_return_value, 'return value')
def test_failure_of_value_type(self): # ARRANGE # actual_container = StringSymbolValueContext.of_arbitrary_value( ).container assertion_to_check = sut.matches_container( value_type=asrt.is_(ValueType.PATH), sdv=asrt.anything_goes(), definition_source=asrt.anything_goes()) assert_that_assertion_fails(assertion_to_check, actual_container)
def test_look_ahead_state_pass(self): # ARRANGE # assertion = sut.assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.NULL)) # ACT & ASSERT # token_stream = TokenStream('') self.assertTrue(token_stream.look_ahead_state is LookAheadState.NULL, 'sanity check: this test assumes that the constructor of the token parser ' 'sets correct look-ahead state') assertion.apply_without_message(self, token_stream)
def is_failure(status: FullExeResultStatus, failure_info: ValueAssertion[Optional[FailureInfo]] = asrt.is_instance(FailureInfo), sds: ValueAssertion[Optional[SandboxDirectoryStructure]] = asrt.anything_goes(), action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] = asrt.anything_goes(), ) -> ValueAssertion[FullExeResult]: return matches(status=asrt.is_(status), sds=sds, action_to_check_outcome=action_to_check_outcome, failure_info=failure_info)
def test_fail(self): # ARRANGE # assertion = sut.assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.NULL)) # ACT & ASSERT # token_stream = TokenStream('a_token') self.assertTrue(token_stream.look_ahead_state is LookAheadState.HAS_TOKEN, 'sanity check: this test assumes that the constructor of the token parser ' 'sets correct look-ahead state') assert_that_assertion_fails(assertion, token_stream)
def equals_simple_phase_step( expected: SimplePhaseStep) -> Assertion[SimplePhaseStep]: assert isinstance(expected, SimplePhaseStep), 'Must be SimplePhaseStep' return asrt.and_([ asrt.sub_component('phase', SimplePhaseStep.phase.fget, asrt.is_(expected.phase)), asrt.sub_component('step', SimplePhaseStep.step.fget, asrt.equals(expected.step)), ])
def test_resolver_SHOULD_be_given_as_argument_to_resolver_assertion(self): # ARRANGE # actual_resolver = string_resolvers.str_constant('s') actual_container = container_of_builtin(actual_resolver) assertion_that_is_expected_to_succeed = asrt.is_(actual_resolver) assertion_to_check = sut.matches_container(assertion_that_is_expected_to_succeed, assertion_on_source=asrt.anything_goes()) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_container)
def test_pass_with_default_assertion_on_restrictions(self): # ARRANGE # symbol_name = 'symbol name' symbol_reference = SymbolReference(symbol_name, r.ReferenceRestrictionsOnDirectAndIndirect( vr.AnyDataTypeRestriction())) assertion = exactly_lib_test.symbol.test_resources.symbol_usage_assertions.matches_reference( asrt.is_(symbol_name)) # ACT & ASSERT # assertion.apply_without_message(self, symbol_reference)
def is_xpass(sds: Assertion[Optional[SandboxDs]] = asrt.is_instance(SandboxDs), action_to_check_outcome: Assertion[ Optional[ActionToCheckOutcome]] = asrt.is_instance( ActionToCheckOutcome)) -> Assertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.XPASS), failure_info=asrt.is_none, has_sds=asrt.equals(True), sds=sds, has_action_to_check_outcome=asrt.equals(True), action_to_check_outcome=action_to_check_outcome)
def is_type_category_restriction(expected: TypeCategory) -> ValueAssertion[ReferenceRestrictions]: """ Assertion on a :class:`ReferenceRestrictions`, that it is a :class:`TypeCategoryRestriction`, with a given :class:`TypeCategory`. """ return asrt.is_instance_with(TypeCategoryRestriction, asrt.sub_component('type_category', TypeCategoryRestriction.type_category.fget, asrt.is_(expected)))
def test_pass_with_default_assertion_on_restrictions(self): # ARRANGE # symbol_name = 'symbol name' symbol_reference = SymbolReference(symbol_name, r.ReferenceRestrictionsOnDirectAndIndirect( vr.ArbitraryValueWStrRenderingRestriction.of_any())) assertion = symbol_usage_assertions.matches_reference( asrt.is_(symbol_name)) # ACT & ASSERT # assertion.apply_without_message(self, symbol_reference)
def test_accept_SHOULD_invoke_method_for_non_standard_matcher(self): matcher = _BaseClassTestImpl() return_value = 5 visitor = MatcherStdTypeVisitorTestAcceptImpl.new_w_default_to_raise_exception( non_standard_action=assert_argument_satisfies__and_return( self, asrt.is_(matcher), return_value)) # ACT & ASSERT # actual_return_value = matcher.accept(visitor) # ASSERT # self.assertEqual(return_value, actual_return_value, 'return value')
def _run(self, expected: tcs.TestCaseStatus, initial: tcs.TestCaseStatus, argument: str): for source in equivalent_source_variants__with_source_check__consume_last_line( self, argument): self._check( sut.Parser(), source, Arrangement(test_case_status=initial, actor=actor_that_runs_constant_actions()), Expectation(configuration=asrt_conf.matches( status=asrt.is_(expected))))
def equals_simple_phase_step(expected: SimplePhaseStep) -> ValueAssertion[SimplePhaseStep]: assert isinstance(expected, SimplePhaseStep), 'Must be SimplePhaseStep' return asrt.and_([ asrt.sub_component('phase', SimplePhaseStep.phase.fget, asrt.is_(expected.phase)), asrt.sub_component('step', SimplePhaseStep.step.fget, asrt.equals(expected.step)), ])
def _run(self, expected: tcs.TestCaseStatus, initial: tcs.TestCaseStatus, argument: str): for source in equivalent_source_variants__with_source_check(self, argument): self._check(sut.Parser(), source, Arrangement(test_case_status=initial, actor=actor_that_runs_constant_actions()), Expectation(configuration=asrt_conf.has(test_case_status=asrt.is_(expected))))
def test_matches(self): # ARRANGE # expected_detail = StringDetail('the string detail') actual = sut.IndentedDetail([expected_detail]) # EXPECTATION # assertion = sut.is_indented_detail( details=asrt.matches_singleton_sequence(asrt.is_(expected_detail)) ) # ACT & ASSERT # assertion.apply_without_message(self, actual)
def is_xpass(sds: ValueAssertion[Optional[SandboxDirectoryStructure]] = asrt.is_instance(SandboxDirectoryStructure), action_to_check_outcome: ValueAssertion[Optional[ActionToCheckOutcome]] = asrt.is_instance(ActionToCheckOutcome) ) -> ValueAssertion[FullExeResult]: return matches(status=asrt.is_(FullExeResultStatus.XPASS), failure_info=asrt.is_none, has_sds=asrt.equals(True), sds=sds, has_action_to_check_outcome=asrt.equals(True), action_to_check_outcome=action_to_check_outcome)
def matches2(status: FullExeResultStatus, sds: ValueAssertion[FullExeResult], action_to_check_outcome: ValueAssertion[FullExeResult], failure_info: ValueAssertion[Optional[FailureInfo]] = asrt.anything_goes() ) -> ValueAssertion[FullExeResult]: return asrt.and_([ matches(status=asrt.is_(status), failure_info=failure_info), sds, action_to_check_outcome, ])
def test_SHOULD_match_WHEN_references_match(self): # ARRANGE # actual_reference = data_references.reference_to__on_direct_and_indirect( 'referenced element') actual_references = [actual_reference] actual_sdv = arbitrary_sdv_with_references(actual_references) assertion_to_check = _matches_string_matcher_sdv( references=asrt.matches_sequence([asrt.is_(actual_reference)]), ) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_sdv)
def matches2( status: FullExeResultStatus, sds: Assertion[FullExeResult], action_to_check_outcome: Assertion[FullExeResult], failure_info: Assertion[Optional[FailureInfo]] = asrt.anything_goes() ) -> Assertion[FullExeResult]: return asrt.and_([ matches(status=asrt.is_(status), failure_info=failure_info), sds, action_to_check_outcome, ])
def test_not_matches(self): expected_command = system_program_command('program', []) expected_stdin_data = StdinData([]) expected_transformer = IdentityStringTransformer() assertion = sut.matches_program( command=asrt.is_(expected_command), stdin=asrt.is_(expected_stdin_data), transformer=asrt.is_(expected_transformer), ) actual_command = system_program_command('program', []) actual_stdin_data = StdinData([]) actual_transformer = IdentityStringTransformer() cases = [ NameAndValue('unexpected command', Program( command=actual_command, stdin=expected_stdin_data, transformation=expected_transformer ) ), NameAndValue('unexpected stdin', Program( command=expected_command, stdin=actual_stdin_data, transformation=expected_transformer ) ), NameAndValue('unexpected transformer', Program( command=expected_command, stdin=expected_stdin_data, transformation=actual_transformer ) ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(assertion, case.value)
def test_element_from_instruction_parser_SHOULD_be_assigned_to_section_contents_element( self): expected_instruction_info = InstructionInfo(Instruction(), 'description') expected = sut.ParsedInstruction( line_source.LineSequence(1, ('first line text', )), expected_instruction_info) parser = sut.standard_syntax_element_parser( _InstructionParserThatGivesConstant(expected)) source = _source_for_lines(['ignored', 'source', 'lines']) # ACT # element = parser.parse(ARBITRARY_FS_LOCATION_INFO, source) # ASSERT # element_assertion = matches_instruction( source=asrt.is_(expected.source), instruction_info=matches_instruction_info( assertion_on_description=asrt.is_( expected_instruction_info.description), assertion_on_instruction=asrt.is_( expected_instruction_info.instruction))) element_assertion.apply_with_message(self, element, 'element')
def is_failure( status: FullExeResultStatus, failure_info: Assertion[Optional[FailureInfo]] = asrt.is_instance( FailureInfo), sds: Assertion[Optional[SandboxDs]] = asrt.anything_goes(), action_to_check_outcome: Assertion[ Optional[ActionToCheckOutcome]] = asrt.anything_goes(), ) -> Assertion[FullExeResult]: return matches(status=asrt.is_(status), sds=sds, action_to_check_outcome=action_to_check_outcome, failure_info=failure_info)
def test_matches(self): # ARRANGE # instruction = Instruction() description = 'the description' instruction_info = InstructionInfo(instruction, description) actual_element = ParsedInstruction(LINE_SEQUENCE, instruction_info) assertion = sut.matches_instruction(equals_line_sequence(LINE_SEQUENCE), matches_instruction_info(asrt.equals(description), asrt.is_(instruction))) # ACT & ASSERT # assertion.apply_without_message(self, actual_element)
def test_SHOULD_match_WHEN_references_match(self): # ARRANGE # actual_reference = data_symbol_utils.symbol_reference('referenced element') actual_references = [actual_reference] actual_resolver = arbitrary_resolver_with_references(actual_references) assertion_to_check = sut.matches_string_matcher_resolver(references=asrt.matches_sequence([ asrt.is_(actual_reference) ]), ) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_resolver)
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.equals(arguments), ), stdin=asrt.matches_singleton_sequence( asrt_str_src.matches__str( asrt.equals(str_src_contents), )), transformer=asrt.matches_singleton_sequence( asrt.is_(transformer_symbol.primitive)), )
def test_matches(self): ex = ValueError('an exception') cases = [ NEA('expected type of exception', expected= sut.matches_exception(asrt.is_(ex)), actual= FailureDetails.new_exception(ex), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def test_arbitrary_failure(self): # ARRANGE # actual_container = container_of_builtin(string_resolvers.str_constant('s')) actual_definition = SymbolDefinition('the name', actual_container) assertion_that_is_expected_to_succeed = asrt.not_(asrt.is_(actual_container)) assertion_to_check = exactly_lib_test.symbol.test_resources.symbol_usage_assertions.matches_definition( name=asrt.anything_goes(), container=assertion_that_is_expected_to_succeed) # ACT & ASSERT # assert_that_assertion_fails(assertion_to_check, actual_definition)
def test_container_SHOULD_be_given_as_argument_to_assertion_on_container(self): # ARRANGE # actual_container = container_of_builtin(string_resolvers.str_constant('s')) actual_definition = SymbolDefinition('the name', actual_container) assertion_that_is_expected_to_succeed = asrt.is_(actual_container) assertion_to_check = exactly_lib_test.symbol.test_resources.symbol_usage_assertions.matches_definition( name=asrt.anything_goes(), container=assertion_that_is_expected_to_succeed) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_definition)
def test_sdv_SHOULD_be_given_as_argument_to_sdv_assertion(self): # ARRANGE # actual_sdv = string_sdvs.str_constant('s') builtin_symbol = StringSymbolValueContext.of_sdv( actual_sdv, definition_source=None) assertion_that_is_expected_to_succeed = asrt.is_(actual_sdv) assertion_to_check = sut.matches_container( asrt.anything_goes(), assertion_that_is_expected_to_succeed, definition_source=asrt.anything_goes()) # ACT & ASSERT # assertion_to_check.apply_without_message(self, builtin_symbol.container)
def test_symbol_table_is_passed_to_resolve_method(self): # ARRANGE # symbol_name = 'symbol_name' string_resolver = _StringResolverTestImpl(resolve_string_via_symbol_table(symbol_name)) symbol_table = singleton_symbol_table_2(symbol_name, data_symbol_utils.string_value_constant_container2(STRING_VALUE)) assertion = sut.matches_resolver(asrt.anything_goes(), asrt.anything_goes(), asrt.is_(STRING_VALUE), symbols=symbol_table) # ACT & ASSERT # assertion.apply_without_message(self, string_resolver)
def test_accept_visitor_invokes_correct_method(self): # ARRANGE # operand = constant.MatcherWithConstantResult(False) matcher = sut.Negation(operand) return_value = 5 visitor = MatcherStdTypeVisitorTestAcceptImpl.new_w_default_to_raise_exception( negation_action=assert_argument_satisfies__and_return( self, asrt.is_(operand), return_value)) # ACT & ASSERT # actual_return_value = matcher.accept(visitor) # ASSERT # self.assertEqual(return_value, actual_return_value, 'return value')
def test_equals_references(self): # ARRANGE # actual_reference = data_symbol_utils.symbol_reference('referenced element') actual_references = [actual_reference] actual_resolver = LineMatcherResolverConstantTestImpl( LineMatcherConstant(False), references=actual_references) assertion_to_check = sut.resolved_value_equals_line_matcher(actual_resolver.resolved_value, references=asrt.matches_sequence([ asrt.is_(actual_reference) ]), ) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_resolver)
def test_container_SHOULD_be_given_as_argument_to_assertion_on_container(self): # ARRANGE # builtin_symbol = StringSymbolContext.of_constant('the name', 's', definition_source=None) actual_definition = builtin_symbol.definition actual_container = actual_definition.symbol_container assertion_that_is_expected_to_succeed = asrt.is_(actual_container) assertion_to_check = symbol_usage_assertions.matches_definition( name=asrt.anything_goes(), container=assertion_that_is_expected_to_succeed) # ACT & ASSERT # assertion_to_check.apply_without_message(self, actual_definition)
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 test_SHOULD_not_match_WHEN_references_do_not_match(self): # ARRANGE # actual_reference = data_symbol_utils.symbol_reference('referenced element') actual_references = [actual_reference] actual_resolver = arbitrary_resolver_with_references(actual_references) cases = [ NameAndValue('assert no references', asrt.is_empty_sequence), NameAndValue('assert single invalid reference', asrt.matches_sequence([ asrt.not_(asrt.is_(actual_reference)) ])), ] for case in cases: with self.subTest(name=case.name): assertion_to_check = sut.matches_regex_resolver(references=case.value) # ACT & ASSERT # assert_that_assertion_fails(assertion_to_check, actual_resolver)
def test_succeed_WHEN_table_contains_the_expected_element(self): a_symbol = NameAndValue('symbol name', ASymbolTableValue('symbol value')) cases = [ ('assertion is', a_symbol, asrt.is_(a_symbol.value) ), ('assertion has expected value', a_symbol, assert_string_value_equals(a_symbol.value.value) ), ] for name, symbol, value_assertion in cases: with self.subTest(name=name): # ARRANGE # actual = SymbolTable({symbol.name: symbol.value}) assertion = sut.assert_symbol_table_is_singleton(symbol.name, value_assertion) # ACT # assertion.apply_without_message(self, actual)
def test_not_equals_references(self): # ARRANGE # actual_reference = data_symbol_utils.symbol_reference('referenced element') actual_references = [actual_reference] actual_resolver = LineMatcherResolverConstantTestImpl( LineMatcherConstant(False), references=actual_references) cases = [ NameAndValue('assert no references', asrt.is_empty_sequence), NameAndValue('assert single invalid reference', asrt.matches_sequence([ asrt.not_(asrt.is_(actual_reference)) ])), ] for case in cases: with self.subTest(name=case.name): assertion_to_check = sut.resolved_value_equals_line_matcher(actual_resolver.resolved_value, references=case.value, ) # ACT & ASSERT # assert_that_assertion_fails(assertion_to_check, actual_resolver)
def test_false__with_message_builder(self): expected_object = 'expected object' actual_object = 'actual object' with self.assertRaises(TestException): sut.is_(expected_object).apply(self.put, actual_object, sut.MessageBuilder('head'))
def test_true(self): expected_object = 'expected object' sut.is_(expected_object).apply(self.put, expected_object) sut.is_(expected_object).apply(self.put, expected_object, sut.MessageBuilder('head'))
def test(self): test_cases = [ # Single token ('a', 'a', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals(''))), ('b ', 'b ', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(2), remaining_source=asrt.equals(''))), ('x \n', 'x ', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(2), remaining_source=asrt.equals('\n')) ), ('x\ny', 'x', assert_token_stream(head_token=assert_plain('y'), look_ahead_state=asrt.is_not(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals('\ny')) ), ('x\n y', 'x', assert_token_stream(head_token=assert_plain('y'), look_ahead_state=asrt.is_not(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals('\n y')) ), # Multiple tokens ('a A', 'a A', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(3), remaining_source=asrt.equals('')) ), ('a A\nb B', 'a A', assert_token_stream(head_token=assert_plain('b'), look_ahead_state=asrt.is_not(LookAheadState.NULL), position=asrt.equals(3), remaining_source=asrt.equals('\nb B')) ), ('a A\ninvalid_token"', 'a A', assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.SYNTAX_ERROR), is_null=asrt.is_true, position=asrt.equals(3), remaining_source=asrt.equals('\ninvalid_token"')) ), # No tokens ('', '', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(0), remaining_source=asrt.equals('')) ), (' ', ' ', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals('')) ), (' \n', ' ', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals('\n')) ), (' \n ', ' ', assert_token_stream(is_null=asrt.is_true, look_ahead_state=asrt.is_(LookAheadState.NULL), position=asrt.equals(1), remaining_source=asrt.equals('\n ')) ), (' \n"invalid quoting', ' ', assert_token_stream(look_ahead_state=asrt.is_(LookAheadState.SYNTAX_ERROR), position=asrt.equals(1), remaining_source=asrt.equals('\n"invalid quoting')) ), ] for source, expected_consumed_string, token_stream_assertion in test_cases: with self.subTest(msg=repr(source)): ts = sut.TokenStream(source) # ACT # actual_consumed_string = ts.consume_remaining_part_of_current_line_as_string() # ASSERT # self.assertEqual(expected_consumed_string, actual_consumed_string, 'consumed string') token_stream_assertion.apply_with_message(self, ts, 'token stream after parse')