def test_multiple_minor_blocks(self):
# ARRANGE #
string_1 = 'the 1st string'
string_2 = 'the 2nd string'
string_3 = 'the 3rd string'
cases = [
NEA(
'multiple types, with different indent properties',
lines_content([
MAJOR_BLOCK_INDENT + string_1,
MINOR_BLOCKS_SEPARATOR,
MAJOR_BLOCK_INDENT + MINOR_BLOCK_INDENT +
LINE_ELEMENT_INDENT + string_2,
MINOR_BLOCKS_SEPARATOR,
string_3,
]),
s.MajorBlock(
[
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_1),
s.ELEMENT_PROPERTIES__NEUTRAL,
),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
),
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_2),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
),
s.MinorBlock(
[
s.LineElement(
s.PreFormattedStringLineObject(
string_3, False),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
)
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_major_block(
self,
case.actual,
case.expected,
)
def test_color_and_font_style_SHOULD_cause_text_to_be_surrounded_by_color_and_style_codes(
self):
# ARRANGE #
text_color = ForegroundColor.BLUE
font_style = FontStyle.BOLD
line_object = s.StringLineObject('line object text',
string_is_line_ended=False)
# ACT & ASSERT #
check_line_element(
self,
s.LineElement(
line_object,
ElementProperties(
s.INDENTATION__NEUTRAL,
TextStyle(color=text_color, font_style=font_style))),
''.join([
FilePrinterWithTextPropertiesForTest.font_style_string_for(
font_style),
FilePrinterWithTextPropertiesForTest.color_string_for(
text_color),
line_object.string,
'\n',
FilePrinterWithTextPropertiesForTest.UNSET_COLOR,
FilePrinterWithTextPropertiesForTest.UNSET_FONT_STYLE,
]),
)
def test_indentation_element_properties_SHOULD_be_accumulated(self):
# ARRANGE #
line_object = s.StringLineObject('the string')
block_properties = ElementProperties(
Indentation(2, '<block indent suffix>'),
TEXT_STYLE__NEUTRAL,
)
line_element_properties = ElementProperties(
Indentation(3, '<line element indent suffix>'),
TEXT_STYLE__NEUTRAL,
)
# ACT & ASSERT #
check_minor_block(
self,
to_render=s.MinorBlock(
[s.LineElement(line_object, line_element_properties)],
block_properties,
),
expectation=lines_content([
((LAYOUT_SETTINGS.minor_block.indent *
block_properties.indentation.level) +
block_properties.indentation.suffix +
(LAYOUT_SETTINGS.line_element_indent *
line_element_properties.indentation.level) +
line_element_properties.indentation.suffix +
line_object.string)
]),
)
def render(self) -> MajorBlock:
the_list = self._list.render_sequence()
header = _type_of_x_elements_header(len(the_list),
types.LIST_TYPE_INFO,
type_system.NUMBER_OF_LIST_ELEMENTS)
if len(the_list) == 0:
return _header_only(header)
num_formatter = (
self._format_lt_10
if len(the_list) < 10
else
self._format_gte_10
)
value_list = [
text_struct.LineElement(
text_struct.StringLineObject(
' '.join([num_formatter(n), elem, ]))
)
for n, elem in enumerate(the_list, 1)
]
return _header_and_value(
header,
value_list,
text_struct.ELEMENT_PROPERTIES__INDENTED,
)
def render(self) -> MajorBlock:
return MajorBlock([
MinorBlock([
struct.LineElement(
struct.StringLineObject(self._single_line_info_str())),
])
])
def render(self) -> MajorBlock:
return text_struct.MajorBlock([
text_struct.MinorBlock([
text_struct.LineElement(
text_struct.StringLineObject('program')
)
])
])
def _header_only(header: str) -> text_struct.MajorBlock:
return text_struct.MajorBlock([
text_struct.MinorBlock([
text_struct.LineElement(
text_struct.StringLineObject(header)
)
]),
])
def render(self) -> MinorBlock:
return MinorBlock(
[
text_struct.LineElement(
text_struct.StringLineObject(line.render()))
for line in self._path.renders()
],
self._element_properties,
)
def test_non_empty_blocks_SHOULD_BE_separated_by_single_block_separator(
self):
# ARRANGE #
string_1 = 'the 1st string'
string_2 = 'the 2nd string'
cases = [
NEA(
'two blocks, with different indent properties',
lines_content([
string_1,
MINOR_BLOCKS_SEPARATOR,
MINOR_BLOCK_INDENT + LINE_ELEMENT_INDENT + string_2,
]),
[
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_1),
s.ELEMENT_PROPERTIES__NEUTRAL,
),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
),
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_2),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
),
],
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_minor_blocks(
self,
case.actual,
case.expected,
)
def render(self) -> MajorBlock:
def_report_infos = map(mk_single_def_report_info, self.definitions)
definition_lines = _get_list_lines(def_report_infos)
return MajorBlock([
structure.MinorBlock([
structure.LineElement(
structure.StringLinesObject(definition_lines)
)
])
])
def _header_and_value(header: str,
value: Sequence[text_struct.LineElement],
value_block_properties: text_struct.ElementProperties,
) -> text_struct.MajorBlock:
return text_struct.MajorBlock([
text_struct.MinorBlock([
text_struct.LineElement(
text_struct.StringLineObject(header)
)
]),
text_struct.MinorBlock(
value,
value_block_properties,
),
])
def test_indentation_element_property_SHOULD_cause_indentation(self):
# ARRANGE #
line_object = s.StringLineObject('the string')
for case in _INDENTATION_CASES:
with self.subTest(case.name):
# ACT & ASSERT #
check_minor_block(
self,
to_render=s.MinorBlock(
[s.LineElement(line_object)],
ElementProperties(case.actual, TEXT_STYLE__NEUTRAL),
),
expectation=lines_content(
[case.expected + line_object.string]),
)
def render(self) -> MajorBlock:
s = self._x.render()
header = _type_of_x_elements_header(len(s),
types.STRING_TYPE_INFO,
type_system.NUMBER_OF_STRING_CHARACTERS)
if len(s) == 0:
return _header_only(header)
else:
return _header_and_value(
header,
[text_struct.LineElement(
text_struct.PreFormattedStringLineObject(s, False)
)
],
text_struct.ELEMENT_PROPERTIES__NEUTRAL,
)
def test_non_empty_blocks_SHOULD_BE_separated_by_single_block_separator(
self):
# ARRANGE #
string_1 = 'the 1st string'
string_2 = 'the 2nd string'
cases = [
NEA(
'two blocks, with different indent properties',
lines_content([
string_1,
MAJOR_BLOCKS_SEPARATOR,
MAJOR_BLOCK_INDENT + MINOR_BLOCK_INDENT +
LINE_ELEMENT_INDENT + string_2,
]),
[
s.MajorBlock(
[
single_line_minor_block_w_plain_properties(
string_1),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
),
s.MajorBlock(
[
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_2),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
),
],
),
]
for case in cases:
check_block_sequence_and_document(self, case)
def test_multiple_line_elements(self):
# ARRANGE #
string_1 = 'the 1st string'
string_2 = 'the 2nd string'
string_3 = 'the 3rd string'
string_4 = 'the 4th string'
cases = [
NEA(
'multiple types, with plain block properties',
lines_content([
string_1,
LINE_ELEMENT_INDENT + LINE_ELEMENT_INDENT + string_2,
LINE_ELEMENT_INDENT + string_3,
string_4,
]),
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_1),
s.ELEMENT_PROPERTIES__NEUTRAL,
),
s.LineElement(
s.StringLineObject(string_2),
s.indentation_properties(2),
),
s.LineElement(
s.StringLineObject(string_3),
s.indentation_properties(1),
),
s.LineElement(
s.PreFormattedStringLineObject(string_4, False),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
),
),
NEA(
'multiple types, with indent block properties',
lines_content([
MINOR_BLOCK_INDENT + string_1,
MINOR_BLOCK_INDENT + LINE_ELEMENT_INDENT + string_2,
string_3,
]),
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_1),
s.ELEMENT_PROPERTIES__NEUTRAL,
),
s.LineElement(
s.StringLineObject(string_2),
s.ELEMENT_PROPERTIES__INDENTED,
),
s.LineElement(
s.PreFormattedStringLineObject(string_3, False),
s.ELEMENT_PROPERTIES__INDENTED,
),
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_minor_block(
self,
case.actual,
case.expected,
)
def single_line_element_w_plain_properties(line_contents):
return s.LineElement(
s.StringLineObject(line_contents),
s.ELEMENT_PROPERTIES__NEUTRAL,
)
def render(self) -> MinorBlock:
return MinorBlock([
text_struct.LineElement(
text_struct.StringLineObject(
render_failing_property(self._cause)))
])
def test_empty_blocks_SHOULD_BE_separated_by_single_block_separator(self):
# Have not implemented filtering of non-empty blocks.
# Reason is that such blocks should not be constructed.
# But implement it if it appears to be useful for making
# construction easier.
# ARRANGE #
string_1 = 'the 1st string'
empty_block = s.MinorBlock(
[],
s.ELEMENT_PROPERTIES__NEUTRAL,
)
non_empty_block = s.MinorBlock(
[
s.LineElement(
s.StringLineObject(string_1),
s.ELEMENT_PROPERTIES__NEUTRAL,
),
],
s.ELEMENT_PROPERTIES__NEUTRAL,
)
cases = [
NEA(
'two empty blocks',
lines_content([
MINOR_BLOCKS_SEPARATOR,
]),
[
empty_block,
empty_block,
],
),
NEA(
'first non-empty, second empty',
lines_content([
string_1,
MINOR_BLOCKS_SEPARATOR,
]),
[
non_empty_block,
empty_block,
],
),
NEA(
'first non-empty, second empty',
lines_content([
string_1,
MINOR_BLOCKS_SEPARATOR,
]),
[
non_empty_block,
empty_block,
],
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_minor_blocks(
self,
case.actual,
case.expected,
)
def test_single_line__different_line_object_types_SHOULD_be_handled(self):
# ARRANGE #
single_line_string = 'the string'
single_line_string_2 = 'the other string'
cases = [
NEA(
'StringLine',
MINOR_BLOCK_INDENT + LINE_ELEMENT_INDENT + single_line_string +
'\n',
s.MinorBlock(
[
s.LineElement(
s.StringLineObject(single_line_string),
s.ELEMENT_PROPERTIES__INDENTED,
)
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
NEA(
'PreFormattedLine, without ending new-line',
single_line_string + '\n',
s.MinorBlock(
[
s.LineElement(
s.PreFormattedStringLineObject(
single_line_string, False),
s.ELEMENT_PROPERTIES__INDENTED,
)
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
NEA(
'PreFormattedLine, with ending new-line',
single_line_string + '\n',
s.MinorBlock(
[
s.LineElement(
s.PreFormattedStringLineObject(
single_line_string + '\n', True),
s.ELEMENT_PROPERTIES__INDENTED,
)
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
NEA(
'StringLines',
lines_content([
MINOR_BLOCK_INDENT + LINE_ELEMENT_INDENT +
single_line_string,
MINOR_BLOCK_INDENT + LINE_ELEMENT_INDENT +
single_line_string_2,
]),
s.MinorBlock(
[
s.LineElement(
s.StringLinesObject(
[single_line_string, single_line_string_2]),
s.ELEMENT_PROPERTIES__INDENTED,
)
],
s.ELEMENT_PROPERTIES__INDENTED,
),
),
]
for case in cases:
with self.subTest(case.name):
# ACT & ASSERT #
check_minor_block(
self,
case.actual,
case.expected,
)
return helper.apply(sdv, model)
def _file_matcher_for_expectation_type(self) -> FileMatcherSdv:
return (self.file_matcher if self._is_positive_check() else
combinator_sdvs.Negation(self.file_matcher))
def _is_positive_check(self) -> bool:
return self.expectation_type is ExpectationType.POSITIVE
_ERROR_MESSAGE_HEADER = 'Failure for path:'
_FILE_EXISTS_BUT_INVALID_PROPERTIES_ERR_MSG_HEADER = rend_comb.SingletonSequenceR(
rend_comb.ConstantR(
text_struct.LineElement(
text_struct.StringLineObject('File exists, but:'))))
_EXISTING_PATH_FAILURE_FORMAT_MAP = {
'PATH': syntax_elements.PATH_SYNTAX_ELEMENT.singular_name,
'FILE_MATCHER': syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.singular_name,
}
_PROPERTIES_DESCRIPTION = """\
Applies a {FILE_MATCHER} on {PATH}, if it exists.
"""
_NOTES = """\
Symbolic links are not followed in the test of existence
(so a broken symbolic link is considered to exist).
"""
