def test_empty_chain(self):
# ARRANGE #
cases = [
NIE('referrer location is .',
expected_value=([], Path('.')),
input_value=Path('.'),
),
NIE('referrer location is dir',
expected_value=([], Path('a-dir')),
input_value=Path('a-dir'),
),
]
for case in cases:
with self.subTest(case.name):
# ACT #
line_elements, referrer_location = sut.file_inclusion_chain(case.input_value, [])
output = print_line_elements(line_elements)
# ASSERT #
self.assertEqual(lines_str(case.expected_value[0]), output,
'output')
self.assertEqual(case.expected_value[1],
referrer_location,
'referrer location')
def test(self):
# ARRANGE #
single_line = ['the single line']
multiple_lines = [
'first',
'second',
]
cases = [
NIE('single line',
expected_source_line_lines(single_line),
single_line
),
NIE('multiple lines',
expected_source_line_lines(multiple_lines),
multiple_lines,
),
]
formatter = sut.default_formatter()
for case in cases:
with self.subTest(case.name):
# ACT #
actual = formatter.source_lines(case.input_value)
# ASSERT #
self.assertEqual(case.expected_value,
actual)
def test(self):
# ARRANGE #
single_line = ['the single line']
multiple_lines = [
'first',
'second',
]
cases = [
NIE('single line',
expected_source_line_lines(single_line),
single_line
),
NIE('multiple lines',
expected_source_line_lines(multiple_lines),
multiple_lines,
),
]
for case in cases:
with self.subTest(case.name):
# ACT #
actual_line_element = sut.source_lines_element(case.input_value)
actual = print_line_element(actual_line_element)
# ASSERT #
self.assertEqual(lines_str(case.expected_value),
actual)
def test_empty_chain(self):
# ARRANGE #
cases = [
NIE('referrer location is .',
expected_value=([], Path('.')),
input_value=Path('.'),
),
NIE('referrer location is dir',
expected_value=([], Path('a-dir')),
input_value=Path('a-dir'),
),
]
formatter = sut.default_formatter()
for case in cases:
with self.subTest(case.name):
# ACT #
block, referrer_location = formatter.file_inclusion_chain(case.input_value,
[])
# ASSERT #
self.assertEqual(case.expected_value[0], block,
'block')
self.assertEqual(case.expected_value[1],
referrer_location,
'referrer location')
def test_system_program(self):
# ARRANGE #
program_name = 'program_name'
cases = [
NIE('without arguments',
expected_value=[program_name],
input_value=[],
),
NIE('with arguments',
expected_value=[program_name, 'arg1', 'arg2'],
input_value=['arg1', 'arg2'],
),
]
for case in cases:
with self.subTest(case.name):
command = Command(CommandDriverForSystemProgram(program_name),
case.input_value)
# ACT #
actual = self.factory.make(command)
# ASSERT #
self.assertFalse(actual.is_shell)
self.assertIsInstance(actual.arg_list_or_str, list)
self.assertEqual(case.expected_value, actual.arg_list_or_str)
def test_shell(self):
# ARRANGE #
command_line = 'command line'
cases = [
NIE('without arguments',
expected_value=command_line,
input_value=[],
),
NIE('with arguments',
expected_value=command_line + ' arg1 arg2',
input_value=['arg1', 'arg2'],
),
]
for case in cases:
with self.subTest(case.name):
command = Command(CommandDriverForShell(command_line),
case.input_value)
# ACT #
actual = self.factory.make(command)
# ASSERT #
self.assertTrue(actual.is_shell)
self.assertIsInstance(actual.arg_list_or_str, str)
self.assertEqual(case.expected_value, actual.arg_list_or_str)
def test_not_matches(self):
cases = [
NIE(
'default assertion/not a renderer',
input_value=self._LINE_ELEMENT,
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/not a sequence',
input_value=rend_comb.ConstantR(self._LINE_ELEMENT),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/not a line element',
input_value=rend_comb.ConstantSequenceR([MajorBlock([])]),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'default assertion/invalid contents of line element',
input_value=rend_comb.ConstantSequenceR([
LineElement(StringLineObject('string'), 'not properties')
]),
expected_value=sut.is_renderer_of_line_elements(),
),
NIE(
'custom assertion/unexpected number of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_line_elements(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected_value,
case.input_value)
def test_not_matches(self):
cases = [
NIE(
'default assertion/not a renderer',
input_value=MajorBlock([]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/not a sequence',
input_value=rend_comb.ConstantR(MajorBlock([])),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/not a major block',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'default assertion/invalid contents of block',
input_value=rend_comb.ConstantSequenceR(
[MajorBlock(['not a minor block'])]),
expected_value=sut.is_renderer_of_major_blocks(),
),
NIE(
'custom assertion/unexpected number of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_major_blocks(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected_value,
case.input_value)
def test_executable_file(self):
# ARRANGE #
the_file = pathlib.Path('the dir') / 'the file'
cases = [
NIE('without arguments',
expected_value=[str(the_file)],
input_value=[],
),
NIE('with arguments',
expected_value=[str(the_file), 'arg1', 'arg2'],
input_value=['arg1', 'arg2'],
),
]
for case in cases:
with self.subTest(case.name):
command = Command(CommandDriverForExecutableFile(new_primitive(the_file)),
case.input_value)
# ACT #
actual = self.factory.make(command)
# ASSERT #
self.assertFalse(actual.is_shell)
self.assertIsInstance(actual.arg_list_or_str, list)
self.assertEqual(case.expected_value, actual.arg_list_or_str)
def runTest(self):
# ARRANGE #
opt_new_line = ['the', 'optional', 'new', 'line']
layout_spec = LayoutSpec(optional_new_line=opt_new_line)
cases = [
NIE(
'first',
input_value={TokenPosition.FIRST},
expected_value=[],
),
NIE(
'last',
input_value={TokenPosition.LAST},
expected_value=[],
),
NIE(
'first and last',
input_value={TokenPosition.FIRST, TokenPosition.LAST},
expected_value=[],
),
NIE(
'neither first nor last',
input_value=set(),
expected_value=['\n'],
),
]
for case in cases:
with self.subTest(case.name):
# ACT #
actual = sut.NEW_LINE_IF_NOT_FIRST_OR_LAST.layout(
layout_spec, case.input_value)
# ASSERT #
self.assertEqual(case.expected_value, actual)
def runTest(self):
# ARRANGE #
cases = [
NIE(
'infix op of precedence 1',
input_value=_src_of([Pa.name, IOP_1u, Pb.name]),
expected_value=InfixOp1u([Pa.value, Pb.value]),
),
NIE(
'infix op of precedence 1, and prefix operator',
input_value=_src_of([POP, Pa.name, IOP_1u, POP, Pb.name]),
expected_value=InfixOp1u(
[PrefixOp(Pa.value),
PrefixOp(Pb.value)]),
),
NIE(
'infix op of precedence 2',
input_value=_src_of([Pa.name, IOP_2u, Pb.name]),
expected_value=InfixOp2u([Pa.value, Pb.value]),
),
NIE(
'infix op of precedence 2, and prefix operator',
input_value=_src_of([POP, Pa.name, IOP_2u, POP, Pb.name]),
expected_value=InfixOp2u(
[PrefixOp(Pa.value),
PrefixOp(Pb.value)]),
),
]
# ACT & ASSERT #
check__full_and_simple_within_parentheses__multi(
self,
cases,
)
def runTest(self):
cases = [
NIE(
'start=1, width=0',
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11'],
Conf(start=1, width=0, num_items_to_take=11),
),
NIE(
'start=1, width=1',
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11'],
Conf(start=1, width=1, num_items_to_take=11),
),
NIE(
'start=0, width=2',
['00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11'],
Conf(start=0, width=2, num_items_to_take=12),
),
]
for case in cases:
with self.subTest(case.name):
conf = case.input_value
# ACT #
actual = sut.int_strings(conf.start, conf.width)
# ASSERT #
actual_to_take = list(itertools.islice(actual, conf.num_items_to_take))
self.assertEqual(case.expected_value,
actual_to_take)
def runTest(self):
# ARRANGE #
cases = [
NIE(
'single infix op of every precedence / highest first',
input_value=_src_of(
[Pa.name, IOP_1u, Pb.name, IOP_2u, Pc.name]),
expected_value=InfixOp2u([
InfixOp1u([Pa.value, Pb.value]),
Pc.value,
]),
),
NIE(
'single infix op of every precedence / lowest first',
input_value=_src_of(
[Pa.name, IOP_2u, Pb.name, IOP_1u, Pc.name]),
expected_value=InfixOp2u([
Pa.value,
InfixOp1u([Pb.value, Pc.value]),
]),
),
NIE(
'infix op of lowest, surrounded by infix-op-expr of higher on each side',
input_value=_src_of([
Pa.name, IOP_1u, Pb.name, IOP_2u, Pc.name, IOP_1u, Pd.name
]),
expected_value=InfixOp2u([
InfixOp1u([Pa.value, Pb.value]),
InfixOp1u([Pc.value, Pd.value]),
]),
),
NIE(
'2 infix-op of lowest, with 3 arguments: simple, infix-op-highest-expr, simple',
input_value=_src_of([
Pa.name, IOP_2u, Pb.name, IOP_1u, Pc.name, IOP_2u, Pd.name
]),
expected_value=InfixOp2u([
Pa.value,
InfixOp1u([Pb.value, Pc.value]),
Pd.value,
]),
),
NIE(
'',
input_value=_src_of([
Pa.name, IOP_1u, Pb.name, IOP_2u, Pc.name, IOP_1v, Pd.name,
IOP_1u, Pe.name
]),
expected_value=InfixOp2u([
InfixOp1u([Pa.value, Pb.value]),
InfixOp1u([InfixOp1v([Pc.value, Pd.value]), Pe.value]),
]),
),
]
# ACT & ASSERT #
check__full_and_simple_within_parentheses__multi(
self,
cases,
)
def test_removal_of_new_lines_SHOULD_join_lines(self):
# ARRANGE #
cases = [
NIE('final line not ended by new-line',
input_value=[
'1\n',
'2\n',
'3',
],
expected_value=[
'123',
]),
NIE('final line ended by new-line',
input_value=[
'1\n',
'2\n',
'3\n',
],
expected_value=[
'123',
]),
]
for line_filter_case in LINE_FILTER_CASES:
for case in cases:
with self.subTest(model=case.name,
line_filtering=line_filter_case.name):
nl_string_symbol = StringConstantSymbolContext(
'NL',
'\n',
default_restrictions=asrt_regex.
is_reference_restrictions__regex(),
)
all_symbols = line_filter_case.value.symbols + [
nl_string_symbol
]
source = ReplaceRegexAbsStx(
nl_string_symbol.abstract_syntax,
StringLiteralAbsStx.empty_string(),
preserve_new_lines=False,
lines_filter=line_filter_case.value.syntax,
)
# ACT & ASSERT #
integration_check.CHECKER__PARSE_SIMPLE.check__abs_stx(
self, source,
model_constructor.of_lines(self, case.input_value),
arrangement_w_tcds(
symbols=SymbolContext.symbol_table_of_contexts(
all_symbols), ),
expectation_of_successful_replace_execution(
symbol_references=SymbolContext.
references_assertion_of_contexts(all_symbols),
may_depend_on_external_resources=line_filter_case.
value.may_depend_on_external_resources,
output_lines=case.expected_value,
))
def runTest(self):
max_num_lines = 2
max_num_chars = 10
reader = sut.InitialPartReaderWithRestIndicator(
max_num_lines, max_num_chars)
cases = [
NIE(
'read all, single line',
input_value='x' * (max_num_chars - 1),
expected_value='x' * (max_num_chars - 1),
),
NIE(
'read all, multiple lines',
input_value='1\n2\n',
expected_value='1\n2\n',
),
NIE(
'read limited (num chars), single line',
input_value='x' * (max_num_chars + 1),
expected_value=('x' * max_num_chars) +
sut.InitialPartReaderWithRestIndicator.REST_INDICATOR,
),
NIE(
'read limited (num chars), multiple lines',
input_value='1234567\n1234567\n',
expected_value='1234567\n12' +
sut.InitialPartReaderWithRestIndicator.REST_INDICATOR,
),
NIE(
'read limited (num lines)',
input_value='1\n2\n3\n',
expected_value='1\n2\n' +
sut.InitialPartReaderWithRestIndicator.REST_INDICATOR,
),
]
for case in cases:
with self.subTest(case.name):
input_file = io.StringIO(case.input_value)
# ACT #
actual = reader.read(input_file)
# ASSERT #
self.assertEqual(case.expected_value, actual)
def test_no_source_and_no_description(self):
# ARRANGE #
section_name = 'section-name'
cases = [
NIE(
'with no section',
expected_value=asrt.is_empty_sequence,
input_value=None,
),
NIE('with section',
expected_value=asrt.matches_sequence([
_matches_plain_minor_block_w_single_plain_line(
section_line(section_name))
]),
input_value=section_name),
]
for case in cases:
with self.subTest(case.name, blocks_renderer='minor blocks'):
# ACT #
actual_renderer = source_location.location_minor_blocks_renderer(
def equivalent_source_variants_for_consume_until_end_of_last_line_3(
arguments: str) -> List[NIE[ParseSource, Assertion[ParseSource]]]:
return [
NIE(
'following_lines={}'.format(repr(extra_lines)),
assertion,
_remaining_source__original_plus_extra_lines(
arguments, extra_lines),
) for extra_lines, assertion in
_equivalent_source_variants_for_consume_until_end_of_last_line(
arguments.count('\n') + 1)
]
def equivalent_source_variants_for_consume_until_end_of_last_line2(
arguments: Arguments
) -> List[NIE[ParseSource, Assertion[ParseSource]]]:
return [
NIE(
repr(extra_lines),
assertion,
arguments.followed_by_lines(extra_lines).as_remaining_source,
) for extra_lines, assertion in
_equivalent_source_variants_for_consume_until_end_of_last_line(
arguments.num_lines)
]
def test_header_and_value_detail(self):
# ARRANGE #
text_style__non_neutral = TextStyle(font_style=FontStyle.UNDERLINE)
cases = [
NIE(
'without text style',
TEXT_STYLE__NEUTRAL,
TEXT_STYLE__NEUTRAL,
),
NIE(
'with text style',
text_style__non_neutral,
text_style__non_neutral,
),
]
for case in cases:
with self.subTest(case.name):
value_detail = StringDetail('the value detail')
header_and_value_detail = HeaderAndValueDetail(
'the header', [value_detail], case.input_value)
root = Node('the root', False, [header_and_value_detail], ())
# EXPECTATION #
expectation = matches_trace_with_details(
root,
[
matches_detail_line_element(
header_and_value_detail.header,
depth=0,
text_style=case.expected_value),
matches_string_detail_line_element(value_detail,
depth=1),
],
)
# ACT & ASSERT #
_check(self, root, expectation)
def test_matches(self):
cases = [
NIE(
'default assertion/empty list of blocks',
input_value=rend_comb.ConstantSequenceR([]),
expected_value=sut.is_renderer_of_minor_blocks(),
),
NIE(
'default assertion/non-empty list of blocks',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_minor_blocks(),
),
NIE(
'custom assertion',
input_value=rend_comb.ConstantSequenceR([MinorBlock([])]),
expected_value=sut.is_renderer_of_minor_blocks(
asrt.len_equals(1)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected_value.apply_without_message(
self, case.input_value)
def test_matches(self):
cases = [
NIE(
'default assertion',
input_value=ErrorInfo(_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE),
expected_value=sut.error_info_matches(),
),
NIE(
'description',
input_value=ErrorInfo(_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE),
expected_value=sut.error_info_matches(
description=asrt_err_descr.matches_message()),
),
NIE(
'source location path',
input_value=ErrorInfo(
_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE,
source_location_path=ARBITRARY_SOURCE_LOCATION_PATH,
),
expected_value=sut.error_info_matches(
source_location_path=asrt.is_instance(SourceLocationPath)),
),
NIE(
'section_name',
input_value=ErrorInfo(
_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE,
section_name=self._SECTION_NAME,
),
expected_value=sut.error_info_matches(
section_name=asrt.equals(self._SECTION_NAME)),
),
]
for case in cases:
with self.subTest(case.name):
case.expected_value.apply_without_message(
self, case.input_value)
def test_not_matches(self):
cases = [
NIE(
'default assertion/object of unexpected type',
input_value='not an ErrorInfo',
expected_value=sut.error_info_matches(),
),
NIE(
'description',
input_value=ErrorInfo(_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE),
expected_value=sut.error_info_matches(
description=asrt_err_descr.matches_exception()),
),
NIE(
'source location path',
input_value=ErrorInfo(
_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE,
source_location_path=ARBITRARY_SOURCE_LOCATION_PATH,
),
expected_value=sut.error_info_matches(
source_location_path=asrt.is_none),
),
NIE(
'section_name',
input_value=ErrorInfo(
_ERROR_DESCRIPTION_OF_EMPTY_MESSAGE,
section_name=self._SECTION_NAME + 'unexpected',
),
expected_value=sut.error_info_matches(
section_name=asrt.equals(self._SECTION_NAME)),
),
]
for case in cases:
with self.subTest(case.name):
assert_that_assertion_fails(case.expected_value,
case.input_value)
def runTest(self):
# ARRANGE #
cases = [
NIE(
'just simple',
input_value=_src_of([Pa.name]),
expected_value=Pa.value,
),
NIE(
'prefix op of simple',
input_value=_src_of([POP, Pa.name]),
expected_value=PrefixOp(Pa.value),
),
NIE(
'reference',
input_value=_src_of([REF.name]),
expected_value=REF.value,
),
]
# ACT & ASSERT #
check__simple_and_full__multi(
self,
cases,
)
def trailing_new_lines_cases_w_leading_space(
) -> List[NIE[List[str], List[str]]]:
return [
NIE(
'single line (non-empty) ended by new-line',
input_value=['last\n'],
expected_value=['last'],
),
NIE(
'single line (empty) ended by new-line',
input_value=['\n'],
expected_value=[],
),
NIE(
'non-empty and empty line',
input_value=['1\n', '\n'],
expected_value=['1'],
),
NIE(
'multiple lines - first non-empty',
input_value=['1\n', '\n', '\n'],
expected_value=['1'],
),
NIE(
'multiple lines - every line empty',
input_value=['\n', '\n', '\n'],
expected_value=[],
),
NIE(
'multiple lines - empty sequence before non-empty contents - ended by new-line',
input_value=['\n', '\n', 'non-empty\n'],
expected_value=['\n', '\n', 'non-empty'],
),
NIE(
'multiple lines - empty sequence before non-empty contents - ended sequence of empty lines',
input_value=['\n', '\n', 'non-empty\n', '\n', '\n'],
expected_value=['\n', '\n', 'non-empty'],
),
]
def runTest(self):
cases = [
NIE(
'constant 5',
5,
StringLiteralAbsStx('5'),
),
NIE(
'constant 5 / quoted',
5,
StringLiteralAbsStx('5', QuoteType.SOFT),
),
NIE(
'constant 75',
75,
StringLiteralAbsStx('75'),
),
NIE(
'python expr',
5,
StringLiteralAbsStx('2+3'),
),
NIE(
'python expr with space',
7,
StringLiteralAbsStx('2*3 + 1', QuoteType.HARD),
),
NIE(
'python expr len',
11,
StringLiteralAbsStx('len("hello world")', QuoteType.HARD),
),
]
for case in cases:
with self.subTest(case.name):
CHECKER.check__abs_stx__layout_and_source_variants(
self,
InstructionArgumentsAbsStx.of_int(case.input_value),
Arrangement.phase_agnostic(),
MultiSourceExpectation.phase_agnostic(
instruction_settings=asrt_instr_settings.matches(
timeout=asrt.equals(case.expected_value))),
)
def test_successful_parse(self):
name_pattern = 'the name pattern'
non_matching_name = 'non-matching name'
glob_pattern_arguments = file_matcher_arguments(
name_pattern=name_pattern)
sut_parser = parse_file_matcher.parsers().full
expected_glob_pattern_matcher_sdv = sut_parser.parse(
remaining_source(glob_pattern_arguments))
expected_glob_pattern_matcher = resolving_helper__fake(
).resolve_matcher(expected_glob_pattern_matcher_sdv)
cases = [
NIE(
'name pattern in RHS SHOULD give selection of name pattern',
asrt_matcher.is_equivalent_to(expected_glob_pattern_matcher, [
asrt_matcher.ModelInfo(
file_matcher_models.FileMatcherModelForDescribedPath(
described_path.new_primitive(
pathlib.Path(name_pattern)), )),
asrt_matcher.ModelInfo(
file_matcher_models.FileMatcherModelForDescribedPath(
described_path.new_primitive(
pathlib.Path(non_matching_name)), )),
]),
glob_pattern_arguments,
),
]
# ARRANGE #
defined_name = 'defined_name'
argument_cases = [
NameAndValue('value on same line', '{selector_argument}'),
NameAndValue('value on following line',
'{new_line} {selector_argument}'),
]
for case in cases:
for argument_case in argument_cases:
with self.subTest(case.name, arguments=argument_case.name):
source = single_line_source(
src2(ValueType.FILE_MATCHER,
defined_name,
argument_case.value,
selector_argument=case.input_value), )
expected_container = matches_container(
asrt.equals(ValueType.FILE_MATCHER),
type_sdv_assertions.matches_sdv_of_file_matcher(
references=asrt.is_empty_sequence,
primitive_value=case.expected_value))
expectation = Expectation.phase_agnostic(
symbol_usages=asrt.matches_sequence([
asrt_sym_usage.matches_definition(
asrt.equals(defined_name), expected_container)
]),
symbols_after_main=assert_symbol_table_is_singleton(
defined_name,
expected_container,
))
# ACT & ASSERT #
INSTRUCTION_CHECKER.check(self, source,
Arrangement.phase_agnostic(),
expectation)
def _zero_or_more__choice(choice: str) -> str:
return '[{}]...'.format(choice)
def _one_or_more__choice(choice: str) -> str:
return '({})...'.format(choice)
def _choice_w_multiple_args_from_strings(
multiplicity: arg.Multiplicity,
choices: List[List[str]],
) -> arg.Choice:
return arg.Choice.of_multiple_argument_choices(
multiplicity, [[arg.Named(choice_arg) for choice_arg in choice]
for choice in choices])
_CHOICE_MULTIPLE_CHOICE_ARGUMENTS_CASES = [
NIE('two arguments',
input_value=[['a1', 'a2'], ['b1', 'b2']],
expected_value='|'.join(['a1 a2', 'b1 b2'])),
NIE('mixed number of arguments',
input_value=[['a'], ['b1', 'b2'], ['c1', 'c2', 'c3']],
expected_value='|'.join(['a', 'b1 b2', 'c1 c2 c3'])),
]
if __name__ == '__main__':
unittest.TextTestRunner().run(suite())
def runTest(self):
# ARRANGE #
checked_dir = DirArgumentHelper(RelOptionType.REL_ACT, 'a-dir')
fc_file_1 = 'file-1'
fc_file_2 = 'file-2'
file_name_not_in_fc = 'not-in-fc'
unconditionally_matching_file_matcher = FileMatcherSymbolContext.of_primitive_constant(
'unconditionally_matching_file_matcher', True)
unconditionally_matching_file_matcher_sym_ref_arg = fm_args.SymbolReferenceWReferenceSyntax(
unconditionally_matching_file_matcher.name)
unconditionally_matching_file_matcher_sym_ref_assertion = unconditionally_matching_file_matcher.reference_assertion
symbol_table_with_unconditionally_matching_file_matcher = unconditionally_matching_file_matcher.symbol_table
files_condition_w_2_files_cases = [
NIE(
'no file matcher',
asrt.is_empty_sequence,
fc_args.FilesCondition([
fc_args.FileCondition(fc_file_1),
fc_args.FileCondition(fc_file_2),
]),
),
NIE(
'file matcher on one file',
asrt.matches_sequence([
unconditionally_matching_file_matcher_sym_ref_assertion,
]),
fc_args.FilesCondition([
fc_args.FileCondition(
fc_file_1,
unconditionally_matching_file_matcher_sym_ref_arg),
fc_args.FileCondition(fc_file_2),
]),
),
NIE(
'file matcher on all files',
asrt.matches_sequence([
unconditionally_matching_file_matcher_sym_ref_assertion,
unconditionally_matching_file_matcher_sym_ref_assertion,
]),
fc_args.FilesCondition([
fc_args.FileCondition(
fc_file_1,
unconditionally_matching_file_matcher_sym_ref_arg),
fc_args.FileCondition(
fc_file_2,
unconditionally_matching_file_matcher_sym_ref_arg),
]),
),
]
expectation_of_matching_giving_false = PrimAndExeExpectation.of_exe(
main_result=asrt.equals(False))
model_contents_cases = [
NExArr(
'model is empty',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents([])),
),
NExArr(
'model contains single file with name in FILES-CONDITION',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(fc_file_1)])),
),
NExArr(
'model contains single file with name not in FILES-CONDITION',
expectation_of_matching_giving_false,
Arrangement(
symbols=
symbol_table_with_unconditionally_matching_file_matcher,
tcds=checked_dir.tcds_arrangement_dir_with_contents(
[File.empty(file_name_not_in_fc)])),
),
]
for files_condition_w_2_files_case in files_condition_w_2_files_cases:
with self.subTest(files_condition_w_2_files_case.name):
# ACT & ASSERT #
check_non_full_and_full__multi(
self,
files_condition_w_2_files_case.input_value,
symbol_references=files_condition_w_2_files_case.
expected_value,
model=model_constructor__non_recursive(
checked_dir.path_sdv),
execution=model_contents_cases,
)
def test_non_empty_chain(self):
# ARRANGE #
ls1 = single_line_sequence(1, 'line sequence 1')
ls2 = single_line_sequence(2, 'line sequence 2')
referrer_location_sub_dir = Path('referrer-location-sub-dir')
link_sub_dir = Path('link-sub-dir')
link_sub_dir2 = Path('link-sub-dir-2')
base_name = Path('base-name')
base_name2 = Path('base-name-2')
cases = [
NIE('single link. referrer location is HERE, file_path_rel_referrer=None',
expected_value=FileInclusionChainOutput(
block=[sut.line_number(ls1.first_line_number)] +
expected_source_line_lines(ls1.lines),
next_referrer_location=Path('.'),
),
input_value=FileInclusionChainInput(
referrer_location=Path('.'),
chain=[
SourceLocation(
source=ls1,
file_path_rel_referrer=None
)
]
),
),
NIE('single link. referrer location is HERE, file_path_rel_referrer just base name',
expected_value=FileInclusionChainOutput(
block=expected_path_lines(base_name, ls1.first_line_number) +
expected_source_line_lines(ls1.lines),
next_referrer_location=Path('.'),
),
input_value=FileInclusionChainInput(
referrer_location=Path('.'),
chain=[
SourceLocation(
source=ls1,
file_path_rel_referrer=base_name
)
]
),
),
NIE('single link. referrer location is HERE, file_path_rel_referrer in sub dir',
expected_value=FileInclusionChainOutput(
block=expected_path_lines(link_sub_dir / base_name, ls1.first_line_number) +
expected_source_line_lines(ls1.lines),
next_referrer_location=link_sub_dir,
),
input_value=FileInclusionChainInput(
referrer_location=Path('.'),
chain=[
SourceLocation(
source=ls1,
file_path_rel_referrer=link_sub_dir / base_name
)
]
),
),
NIE('single link. referrer location is sub-dir, file_path_rel_referrer in sub dir',
expected_value=FileInclusionChainOutput(
block=expected_path_lines(
referrer_location_sub_dir / link_sub_dir / base_name,
ls1.first_line_number) +
expected_source_line_lines(ls1.lines),
next_referrer_location=referrer_location_sub_dir / link_sub_dir,
),
input_value=FileInclusionChainInput(
referrer_location=referrer_location_sub_dir,
chain=[
SourceLocation(
source=ls1,
file_path_rel_referrer=link_sub_dir / base_name
)
]
),
),
NIE('multiple links. referrer location is sub-dir, file_path_rel_referrer in sub dir',
expected_value=FileInclusionChainOutput(
block=
(expected_path_lines(
referrer_location_sub_dir / link_sub_dir / base_name,
ls1.first_line_number)
+
expected_source_line_lines(ls1.lines)
+
expected_path_lines(
referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / base_name2,
ls2.first_line_number)
+
expected_source_line_lines(ls2.lines)
),
next_referrer_location=referrer_location_sub_dir / link_sub_dir / link_sub_dir2,
),
input_value=FileInclusionChainInput(
referrer_location=referrer_location_sub_dir,
chain=[
SourceLocation(
source=ls1,
file_path_rel_referrer=link_sub_dir / base_name,
),
SourceLocation(
source=ls2,
file_path_rel_referrer=link_sub_dir2 / base_name2,
),
]
),
),
]
formatter = sut.default_formatter()
for case in cases:
with self.subTest(case.name):
# ACT #
block, referrer_location = formatter.file_inclusion_chain(case.input_value.referrer_location,
case.input_value.chain)
# ASSERT #
self.assertEqual(case.expected_value.block, block,
'block')
self.assertEqual(case.expected_value.next_referrer_location,
referrer_location,
'referrer location')
def test_with_file_inclusion_chain(self):
# ARRANGE #
final_loc_ls = single_line_sequence(0, 'line sequence 0')
final_loc_dir = Path('final-loc-dir')
final_loc_base_name = Path('final-loc-base-name')
final_location = SourceLocation(final_loc_ls,
final_loc_dir / final_loc_base_name)
ls1 = single_line_sequence(1, 'line sequence 1')
ls2 = single_line_sequence(2, 'line sequence 2')
referrer_location_sub_dir = Path('referrer-location-sub-dir')
link_sub_dir = Path('link-sub-dir')
link_sub_dir2 = Path('link-sub-dir-2')
base_name = Path('base-name')
base_name2 = Path('base-name-2')
cases = [
NIE('single link. referrer location is HERE, file_path_rel_referrer/inclusion=None',
expected_value=[
(
[sut.line_number(ls1.first_line_number)]
+
expected_source_line_lines(ls1.lines)
+
expected_path_lines(
final_loc_dir / final_loc_base_name,
final_loc_ls.first_line_number)
),
expected_source_line_lines(final_loc_ls.lines)
],
input_value=SourceLocationPathInput(
referrer_location=Path('.'),
source_location_path=SourceLocationPath(
final_location,
[
SourceLocation(
source=ls1,
file_path_rel_referrer=None
)
])
),
),
NIE('multiple links. referrer location is sub-dir, file_path_rel_referrer in sub dir',
expected_value=[
(expected_path_lines(
referrer_location_sub_dir / link_sub_dir / base_name,
ls1.first_line_number)
+
expected_source_line_lines(ls1.lines)
+
expected_path_lines(
referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / base_name2,
ls2.first_line_number)
+
expected_source_line_lines(ls2.lines)
+
expected_path_lines(
referrer_location_sub_dir / link_sub_dir / link_sub_dir2 / final_loc_dir / final_loc_base_name,
final_loc_ls.first_line_number)
),
expected_source_line_lines(final_loc_ls.lines)
],
input_value=SourceLocationPathInput(
referrer_location=referrer_location_sub_dir,
source_location_path=SourceLocationPath(
final_location,
[
SourceLocation(
source=ls1,
file_path_rel_referrer=link_sub_dir / base_name,
),
SourceLocation(
source=ls2,
file_path_rel_referrer=link_sub_dir2 / base_name2,
),
])
),
),
]
formatter = sut.default_formatter()
for case in cases:
with self.subTest(case.name):
# ACT #
blocks = formatter.source_location_path(case.input_value.referrer_location,
case.input_value.source_location_path)
# ASSERT #
self.assertEqual(case.expected_value, blocks)