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)))
