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_not_matches(self): cases = [ NEA( 'actual is empty list of line elements', expected=sut.matches_major_block( asrt.not_(asrt.is_empty_sequence)), actual=MajorBlock([]), ), NEA( 'actual element is unexpected', expected=sut.matches_major_block( asrt.matches_sequence( [asrt.not_(asrt.is_instance(MinorBlock))])), actual=MajorBlock([MinorBlock([])]), ), NEA( 'unexpected element properties', expected=sut.matches_major_block( asrt.anything_goes(), properties=asrt.not_(asrt.is_instance(ElementProperties))), actual=MajorBlock( [MinorBlock([], ELEMENT_PROPERTIES__NEUTRAL)]), ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(case.expected, case.actual)
def test_fail_due_to_fail_of_side_effects_on_instruction_settings(self): with self.assertRaises(utils.TestError): self._check( utils.ParserThatGives(SUCCESSFUL_INSTRUCTION), single_line_source(), sut.Arrangement(), sut.Expectation(instruction_settings=asrt.not_( asrt.is_instance(InstructionSettings))))
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 test_fail__resolved_value(self): resolved_value = 'resolved value' self._assert_not_matches( single_dir_dep_val_without_dependencies(resolved_value), None, asrt.not_(asrt.equals(resolved_value)) )
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)), ), )
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_fail_due_to_fail_of_side_effects_on_proc_exe_settings(self): with self.assertRaises(utils.TestError): self._check( utils.ParserThatGives(_SUCCESSFUL_INSTRUCTION), utils.single_line_source(), sut.ArrangementPostAct(), Expectation(proc_exe_settings=asrt.not_( asrt.is_instance(ProcessExecutionSettings))), )
def test_fail_due_to_fail_of_side_effects_on_instruction_settings(self): with self.assertRaises(utils.TestError): self._check( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, single_line_source(), sut.arrangement(), sut.Expectation( instruction_settings=asrt.not_(asrt.is_instance(InstructionSettings)), ), )
def test_not_matches(self): # ARRANGE # files_to_include = [pathlib.Path('file name')] actual_element = ParsedFileInclusionDirective(LINE_SEQUENCE, files_to_include) cases = [ NameAndValue('mismatch on source', sut.matches_file_inclusion_directive(asrt.not_(equals_line_sequence(LINE_SEQUENCE)), asrt.equals(files_to_include)) ), NameAndValue('mismatch on files to include', sut.matches_file_inclusion_directive(equals_line_sequence(LINE_SEQUENCE), asrt.not_(asrt.equals(files_to_include))) ), ] for nav in cases: with self.subTest(nav.name): # ACT & ASSERT # assert_that_assertion_fails(nav.value, actual_element)
def test_not_matches(self): # ARRANGE # element_type = ElementType.COMMENT actual_element = ParsedNonInstructionElement(LINE_SEQUENCE, element_type) cases = [ NameAndValue('mismatch on source', sut.matches_non_instruction(asrt.not_(equals_line_sequence(LINE_SEQUENCE)), asrt.equals(element_type)) ), NameAndValue('mismatch on element type', sut.matches_non_instruction(equals_line_sequence(LINE_SEQUENCE), asrt.not_(asrt.equals(element_type))) ), ] for nav in cases: with self.subTest(nav.name): # ACT & ASSERT # assert_that_assertion_fails(nav.value, actual_element)
def test_arbitrary_failure(self): # ARRANGE # actual_resolver = string_resolvers.str_constant('s') source_line = single_line_sequence(1, 'source line') actual_container = SymbolContainer(actual_resolver, su.source_info_for_line_sequence(source_line)) assertion_that_is_expected_to_fail = asrt.not_(equals_line_sequence(source_line)) assertion_to_check = sut.matches_container( assertion_on_resolver=asrt.anything_goes(), assertion_on_source=assertion_that_is_expected_to_fail) assert_that_assertion_fails(assertion_to_check, actual_container)
def test_not_matches(self): cases = [ NEA( 'unexpected line object', expected=sut.matches_line_element( asrt.not_(asrt.is_instance(LineObjectForTest))), actual=LineElement(LineObjectForTest()), ), NEA( 'unexpected element properties', expected=sut.matches_line_element( asrt.anything_goes(), properties=asrt.not_(asrt.is_instance(ElementProperties))), actual=LineElement(LineObjectForTest(), ELEMENT_PROPERTIES__NEUTRAL), ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(case.expected, case.actual)
def test_fail_due_to_side_effects_check(self): for tcds_case in TCDS_CASES: with self.subTest(tcds_case.name): self._check_source_and_exe_variants__failing_assertions( PARSER_THAT_GIVES_SUCCESSFUL_INSTRUCTION, Arrangement.phase_agnostic( tcds=tcds_case.value ), MultiSourceExpectation.phase_agnostic( side_effects_on_tcds=asrt.not_(asrt.is_instance(TestCaseDs)) ), )
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_arbitrary_failure(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.not_(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 # assert_that_assertion_fails(assertion_to_check, actual_definition)
def test_arbitrary_failure(self): # ARRANGE # actual_sdv = string_sdvs.str_constant('s') source_line = single_line_sequence(1, 'source line') actual_container = StringSymbolValueContext( actual_sdv, source_location.source_info_for_line_sequence( source_line)).container assertion_that_is_expected_to_fail = asrt.not_( equals_line_sequence(source_line)) assertion_to_check = sut.matches_container( value_type=asrt.anything_goes(), sdv=asrt.anything_goes(), definition_source=assertion_that_is_expected_to_fail) assert_that_assertion_fails(assertion_to_check, actual_container)
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_SHOULD_not_match_WHEN_references_do_not_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) 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 = _matches_string_matcher_sdv( references=case.value) # ACT & ASSERT # assert_that_assertion_fails(assertion_to_check, actual_sdv)
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_fail__resolved_value(self): resolved_value = 'resolved value' self._assert_not_matches( single_dir_dep_val_without_dependencies(resolved_value), None, asrt.not_(asrt.equals(resolved_value)))