def is_section_item(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
asrt.IsInstance(doc.SectionItem).apply(put, value, message_builder)
assert isinstance(value, doc.SectionItem)
asrt.sub_component('header',
doc.SectionItem.header.fget,
is_text
).apply(put, value, message_builder)
asrt.sub_component('tags',
doc.SectionItem.tags.fget,
asrt.is_instance_with(set,
asrt.on_transformed(list,
asrt.is_sequence_of(asrt.is_instance(str)))
)
).apply(put, value, message_builder)
asrt.sub_component('target',
doc.SectionItem.target.fget,
asrt.is_instance(core.CrossReferenceTarget)),
if isinstance(value, doc.Article):
is_article_contents.apply(put, value.contents,
message_builder.for_sub_component('article_contents'))
elif isinstance(value, doc.Section):
is_section_contents.apply(put, value.contents,
message_builder.for_sub_component('section_contents'))
else:
asrt.fail('Not a {}: {}'.format(str(doc.SectionItem), str(value)))
def test_false__with_message_builder(self):
with self.assertRaises(TestException):
value = ['not none']
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(
self.put, value,
sut.MessageBuilder('message head'))
def __init__(self, put: unittest.TestCase, arrangement: ArrangementPostAct,
expectation: MultiSourceExpectation):
super().__init__(put, arrangement, expectation)
self.put = put
self.arrangement = arrangement
self.expectation = expectation
self.message_builder = asrt.MessageBuilder()
def runTest(self):
# ARRANGE #
may_depend_on_external_resources = False
contents = 'the contents'
expectation = sut.ExpectationOnUnFrozenAndFrozen.equals(
contents,
may_depend_on_external_resources=asrt.equals(
may_depend_on_external_resources),
frozen_may_depend_on_external_resources=asrt.equals(
may_depend_on_external_resources),
)
data__before_and_after_freeze = StringSourceData(
contents, may_depend_on_external_resources)
source_constructor = ConstructorOfStringSourceData(
data__before_and_after_freeze,
data__before_and_after_freeze,
)
for checker_variant in check_variants(expectation):
with self.subTest(checker_variant.name):
# ACT & ASSERT #
checker_variant.value.apply(
self,
sut.SourceConstructors.of_common(source_constructor),
asrt.MessageBuilder(),
)
def __init__(self,
expected: CrossReferenceId,
put: unittest.TestCase,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
self.put = put
self.message_builder = message_builder
self.expected = expected
def test_true(self):
value = [None]
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(self.put, value)
sut.sub_component('component name', lambda x: x[0],
sut.ValueIsNone()).apply(
self.put, value,
sut.MessageBuilder('message head'))
def runTest(self):
command_line_arguments = self.test_case.arrangement.command_line_arguments(
)
sub_process_result = self.main_program_runner.run(
self, command_line_arguments)
message_builder = value_assertion.MessageBuilder(
'(stderr = "%s")' % sub_process_result.stderr)
self.test_case.assertion.apply(self, sub_process_result,
message_builder)
def _execute_validate_post_setup(self,
environment: InstructionEnvironmentForPostSdsStep,
instruction: AssertPhaseInstruction) -> svh.SuccessOrValidationErrorOrHardError:
result = instruction.validate_post_setup(environment)
self.put.assertIsNotNone(result,
'Result from validate method cannot be None')
self.expectation.validation_post_sds.apply(self.put, result,
asrt.MessageBuilder('result of validate/post setup'))
return result
def matcher_that_asserts_model_is_frozen(
put: unittest.TestCase, result: bool,
matcher_name: str) -> MatcherWTrace[TestModelWFreezing]:
assert_model_is_frozen = ActionThatAppliesAssertion2(
put,
asrt.sub_component('is_frozen', TestModelWFreezing.is_frozen,
asrt.equals(True)),
asrt.MessageBuilder(matcher_name))
return MatcherWInitialAction(assert_model_is_frozen.action,
matching_result.of(result))
def test_generate_and_output_SHOULD_output_xhtml(self):
# ARRANGE #
application_help = new_application_help(
default_instructions_setup.INSTRUCTIONS_SETUP,
CONFIGURATION_SECTION_INSTRUCTIONS)
output_file = io.StringIO()
# ACT #
sut.generate_and_output(output_file, application_help)
# ASSERT #
actual_output = output_file.getvalue()
begins_with(DOCTYPE_XHTML1_0).apply(self, actual_output,
asrt.MessageBuilder('file output'))
def __init__(
self,
put: unittest.TestCase,
arrangement: Arrangement,
symbols_after_parse: Assertion[Sequence[SymbolUsage]],
symbols_after_main: Assertion[SymbolTable],
expectation: ExecutionExpectation[T],
):
self.put = put
self.arrangement = arrangement
self.symbols_after_parse = symbols_after_parse
self.symbols_after_main = symbols_after_main
self.expectation = expectation
self.message_builder = asrt.MessageBuilder()
def test__va(put: unittest.TestCase,
test_case: TestCase,
arrangement: Arrangement,
assertions_on_result: Assertion[Result],
is_keep_sandbox_during_assertions: bool = False):
with preserved_cwd():
result = _execute(test_case,
arrangement,
is_keep_sandbox=is_keep_sandbox_during_assertions)
assertions_on_result.apply(put, result, asrt.MessageBuilder('Result'))
# CLEANUP #
if result.sds.root_dir.exists():
shutil.rmtree(str(result.sds.root_dir), ignore_errors=True)
def check(put: unittest.TestCase,
arrangement: Arrangement,
expectation: Expectation,
is_keep_sandbox: bool = False):
exe_conf = ExecutionConfiguration(
arrangement.predefined_properties.default_environ_getter,
arrangement.predefined_properties.environ,
arrangement.predefined_properties.timeout_in_seconds,
arrangement.os_services, sandbox_root_name_resolver.for_test(),
arrangement.mem_buff_size,
arrangement.predefined_properties.predefined_symbols)
result = execution.execute(exe_conf, arrangement.configuration_builder,
is_keep_sandbox, arrangement.test_case)
expectation.full_result.apply(put, result,
asrt.MessageBuilder('FullExeResult'))
def is_section_contents(self,
put: unittest.TestCase,
value,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
asrt.And([
asrt.IsInstance(doc.SectionContents),
asrt.sub_component_sequence('initial_paragraphs',
doc.SectionContents.initial_paragraphs.fget,
is_paragraph_item)
]).apply(put, value, message_builder)
assert isinstance(value, doc.SectionContents)
sections_message = asrt.sub_component_builder('sections', message_builder)
asrt.IsInstance(list).apply(put, value.sections, sections_message)
for (idx, section) in enumerate(value.sections):
self.is_section_item(put, section,
asrt.sub_component_builder('[%d]' % idx, sections_message))
def assert_equals_single_line(test_case: unittest.TestCase,
expected: Line,
actual: LineSequence,
message_header: str = None):
"""
:param expected: May be None
:param actual: May be None
:param message_header: Optional header for assert messages.
"""
if expected is None:
assertion = asrt.is_none
else:
assertion = equals_line_sequence(line_sequence_from_line(expected))
message_builder = asrt.MessageBuilder(
'' if message_header is None else message_header)
assertion.apply(test_case, actual, message_builder)
def check(put: unittest.TestCase,
actual: DdvValidator,
arrangement: Arrangement,
expectation: Expectation,
message_builder: asrt.MessageBuilder = asrt.MessageBuilder()):
with tcds_with_act_as_curr_dir_2(
tcds_contents=arrangement.dir_contents) as tcds:
actual_validation_result = actual.validate_pre_sds_if_applicable(
tcds.hds)
expectation.pre_sds.apply(
put, actual_validation_result,
message_builder.for_sub_component('validation pre sds'))
if actual_validation_result is not None:
return
actual_validation_result = actual.validate_post_sds_if_applicable(tcds)
expectation.post_sds.apply(
put, actual_validation_result,
message_builder.for_sub_component('validation post sds'))
def _check_sdv(
self,
put: unittest.TestCase,
parsed_object,
symbol_references: Assertion[Sequence[SymbolReference]],
):
message_builder = asrt.MessageBuilder('parsed object')
asrt.is_instance(FullDepsSdv).apply(
put, parsed_object,
message_builder.for_sub_component('object type'))
assert isinstance(parsed_object, FullDepsSdv) # Type info for IDE
self._configuration.new_sdv_checker().check(put, parsed_object,
message_builder)
symbol_references.apply(
put, parsed_object.references,
message_builder.for_sub_component('symbol references'))
def __init__(
self,
put: unittest.TestCase,
arrangement: Arrangement,
expectation: Expectation[T],
extra_source_expectation: Assertion[ParseSource] = asrt.anything_goes(
),
):
self.put = put
self.arrangement = arrangement
self.expectation = expectation
self.message_builder = asrt.MessageBuilder()
self.extra_source_expectation = extra_source_expectation
self.parse_checker = _ParseChecker(self.put, expectation.symbol_usages,
expectation.source,
extra_source_expectation)
self.execution_checker = _ExecutionChecker(
self.put, arrangement, expectation.symbol_usages,
expectation.symbols_after_main, expectation)
def _parse(self, source: ParseSource) -> FullDepsSdv[PRIMITIVE]:
sdv = self.parser.parse(source)
self.source_expectation.apply_with_message(
self.put,
source,
'source after parse',
)
message_builder = asrt.MessageBuilder('parsed object')
self.expectation.parse.symbol_references.apply(
self.put,
sdv.references,
message_builder.for_sub_component('symbol references'),
)
self.configuration.new_sdv_checker().check(
self.put,
sdv,
message_builder,
)
return sdv
def _check_instance_and(self, object_name: str, expected_class: type,
additional: Assertion, actual):
asrt.And([asrt.IsInstance(expected_class),
additional]).apply(self.put, actual,
asrt.MessageBuilder(object_name))
def _check_side_effects_on_tcds(self, tcds: TestCaseDs):
self.expectation.main_side_effects_on_tcds.apply(
self.put, tcds, asrt.MessageBuilder('side effects on HomeAndSds'))
def _check_main_side_effects_on_sds(self, tcds: TestCaseDs):
self.expectation.main_side_effects_on_sds.apply(
self.put, tcds.sds,
asrt.MessageBuilder('main side effects on SDS'))
def test_empty_list(self):
self.every_element_is_none.apply(self.put, [])
self.every_element_is_none.apply(self.put, [],
sut.MessageBuilder('message head'))
def test_none(self):
sut.ValueIsNone().apply(self.put, None)
sut.ValueIsNone().apply(self.put, None, sut.MessageBuilder('head'))
def test_not_none(self):
with self.assertRaises(TestException):
sut.ValueIsNone().apply(self.put, 'not none')
with self.assertRaises(TestException):
sut.ValueIsNone().apply(self.put, 'not none',
sut.MessageBuilder('head'))
def _check(self, component: str, assertion: Assertion, actual):
assertion.apply(self.put, actual, asrt.MessageBuilder(component))
return actual
def test_none__with_message_builder(self):
with self.assertRaises(TestException):
sut.ValueIsNotNone().apply(self.put, None,
sut.MessageBuilder('message head'))
def test_not_none(self):
sut.ValueIsNotNone().apply(self.put, 'not none')
sut.ValueIsNotNone().apply(self.put, 'not none',
sut.MessageBuilder('head'))
def test_consume_with_valid_arguments(self):
test_cases = [
(TestSetupForConsume('one whole line and part of next, with one line remaining',
source_lines=['123',
'45',
'6'],
number_of_characters_to_consume_from_current_line_before_test=0,
number_of_characters_to_consume=4 + 1),
assert_source(is_at_eof=asrt.equals(False),
is_at_eol=asrt.equals(False),
is_at_eol__except_for_space=asrt.equals(False),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
column_index=asrt.equals(1),
remaining_part_of_current_line=asrt.equals('5'),
remaining_source=asrt.equals('5\n6'))),
(TestSetupForConsume('one whole line and part of next, with one line remaining, on column index 1',
source_lines=['123',
'45',
'6'],
number_of_characters_to_consume_from_current_line_before_test=1,
number_of_characters_to_consume=4 + 1 - 1),
assert_source(is_at_eof=asrt.equals(False),
is_at_eol=asrt.equals(False),
is_at_eol__except_for_space=asrt.equals(False),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
column_index=asrt.equals(1),
remaining_part_of_current_line=asrt.equals('5'),
remaining_source=asrt.equals('5\n6'))),
(TestSetupForConsume('two whole lines, with one line remaining',
source_lines=['123',
'45',
'6'],
number_of_characters_to_consume_from_current_line_before_test=0,
number_of_characters_to_consume=5 + 1),
assert_source(is_at_eof=asrt.equals(False),
is_at_eol=asrt.equals(True),
is_at_eol__except_for_space=asrt.equals(True),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
column_index=asrt.equals(2),
remaining_part_of_current_line=asrt.equals(''),
remaining_source=asrt.equals('\n6'))),
(TestSetupForConsume('two whole lines, with one line remaining, on column index 2',
source_lines=['123',
'45',
'6'],
number_of_characters_to_consume_from_current_line_before_test=2,
number_of_characters_to_consume=5 + 1 - 2),
assert_source(is_at_eof=asrt.equals(False),
is_at_eol=asrt.equals(True),
is_at_eol__except_for_space=asrt.equals(True),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
column_index=asrt.equals(2),
remaining_part_of_current_line=asrt.equals(''),
remaining_source=asrt.equals('\n6'))),
(TestSetupForConsume('two whole lines, with no line after',
source_lines=['123',
'45'],
number_of_characters_to_consume_from_current_line_before_test=0,
number_of_characters_to_consume=5 + 1),
assert_source(is_at_eof=asrt.equals(True),
is_at_eol=asrt.equals(True),
is_at_eol__except_for_space=asrt.equals(True),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
remaining_part_of_current_line=asrt.equals(''),
remaining_source=asrt.equals(''))),
(TestSetupForConsume('two whole lines, with no line after, on column index 3',
source_lines=['123',
'45'],
number_of_characters_to_consume_from_current_line_before_test=3,
number_of_characters_to_consume=5 + 1 - 3),
assert_source(is_at_eof=asrt.equals(True),
is_at_eol=asrt.equals(True),
is_at_eol__except_for_space=asrt.equals(True),
has_current_line=asrt.equals(True),
current_line_number=asrt.equals(2),
current_line_text=asrt.equals('45'),
column_index=asrt.equals(2),
remaining_part_of_current_line=asrt.equals(''),
remaining_source=asrt.equals(''))),
]
for setup, assertion in test_cases:
with self.subTest(case_name=setup.name):
source_lines = '\n'.join(setup.source_lines)
source = ParseSource(source_lines)
source.consume_part_of_current_line(setup.number_of_characters_to_consume_from_current_line_before_test)
source.consume(setup.number_of_characters_to_consume)
assertion.apply(self, source, asrt.MessageBuilder(setup.name))
def test_true(self):
value = [None]
sut.OnTransformed(lambda x: x[0],
sut.ValueIsNone()).apply(self.put, value)
sut.OnTransformed(lambda x: x[0], sut.ValueIsNone()).apply(
self.put, value, sut.MessageBuilder('message head'))
