def test_successful_parse_WHEN_rhs_is_empty_THEN_result_SHOULD_be_identity_transformer(self):
defined_name = 'defined_name'
# ARRANGE #
source = single_line_source(
src('{lines_trans_type} {defined_name} = ',
defined_name=defined_name),
)
# EXPECTATION #
expected_container = matches_container(
resolved_value_equals_string_transformer(IdentityStringTransformer())
)
expectation = Expectation(
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 #
self._check(source, ArrangementWithSds(), expectation)
def test_successful_parse_of_arbitrary_matcher(self):
defined_name = 'defined_name'
# ARRANGE #
source = single_line_source(
src('{string_matcher_type} {defined_name} = {matcher_argument}',
defined_name=defined_name,
matcher_argument=arg_syntax.arbitrary_single_line_value_that_must_not_be_quoted()),
)
# EXPECTATION #
expected_container = matches_container(
matches_string_matcher_resolver()
)
expectation = Expectation(
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 #
self._check(source, ArrangementWithSds(), expectation)
def test_successful_parse_of_regex(self):
# ARRANGE #
regex_str = 'the_regex'
symbol = NameAndValue('the_symbol_name',
LineMatcherConstant(False))
regex_matcher_syntax = argument_syntax.syntax_for_regex_matcher(regex_str)
matcher_argument = argument_syntax.syntax_for_and([
symbol.name,
regex_matcher_syntax,
])
defined_name = 'defined_name'
source = remaining_source(
src('{line_match_type} {defined_name} = {matcher_argument}',
defined_name=defined_name,
matcher_argument=matcher_argument),
following_lines=['following line'],
)
# EXPECTATION #
the_and_matcher = LineMatcherAnd([
symbol.value,
LineMatcherRegex(re.compile(regex_str)),
])
expected_container = matches_container(
assertion_on_resolver=
resolved_value_equals_line_matcher(
the_and_matcher,
references=asrt.matches_sequence([
is_line_matcher_reference_to(symbol.name),
]),
symbols=SymbolTable({
symbol.name: container(LineMatcherConstantResolver(symbol.value)),
}),
)
)
expectation = Expectation(
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 #
self._check(source, ArrangementWithSds(), expectation)
def test_successful_parse_and_application_of_non_trivial_matcher(self):
# ARRANGE #
defined_name = 'defined_name'
expected_container = matches_container(
asrt.equals(ValueType.FILES_MATCHER),
type_sdv_assertions.matches_sdv_of_files_matcher()
)
not_num_files_beginning_with_a_eq_1_arg = self._not_num_files_beginning_with_a_eq_1_arg()
cases = [
NEA('should match',
expected=matcher_assertions.is_matching_success(),
actual=DirContents([
File.empty('a.x'),
File.empty('a.y'),
File.empty('b.x'),
File.empty('b.y'),
])
),
NEA('should not match',
expected=matcher_assertions.is_arbitrary_matching_failure(),
actual=DirContents([
File.empty('a.x'),
File.empty('b.y'),
File.empty('b.x'),
])
),
]
for case in cases:
source = single_line_source(
src2(ValueType.FILES_MATCHER, defined_name, not_num_files_beginning_with_a_eq_1_arg),
)
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,
),
instruction_environment=
AssertApplicationOfMatcherInSymbolTable(defined_name,
actual_dir_contents=case.actual,
expected_matcher_result=case.expected),
)
def test_container_SHOULD_be_given_as_argument_to_assertion_on_container(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.is_(actual_container)
assertion_to_check = symbol_usage_assertions.matches_definition(
name=asrt.anything_goes(),
container=assertion_that_is_expected_to_succeed)
# ACT & ASSERT #
assertion_to_check.apply_without_message(self, 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)
class TestSuccessfulScenarios(unittest.TestCase):
def test_successful_parse_of_arbitrary_matcher(self):
defined_name = 'defined_name'
file_name = 'the-file-name'
# ARRANGE #
argument_cases = [
NameAndValue('value on same line',
'{files_condition}'
),
NameAndValue('value on following line',
'{new_line} {files_condition}'
),
]
for case in argument_cases:
with self.subTest(case.name):
source = remaining_source(
src2(ValueType.FILES_CONDITION, defined_name, case.value,
files_condition=arg_syntax.FilesCondition([arg_syntax.FileCondition(file_name)])),
)
# EXPECTATION #
expected_container = matches_container(
asrt.equals(ValueType.FILES_CONDITION),
type_sdv_assertions.matches_sdv_of_files_condition_constant(
primitive_value=asrt_primitive.files_matches({
PurePosixPath(file_name): asrt.is_none
})
)
)
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 test_successful_parse_and_application_of_non_trivial_matcher(self):
defined_name = 'defined_name'
expected_container = matches_container(
matches_string_matcher_resolver()
)
not_num_lines_eq_1_matcher_arg = self._not_num_lines_eq_1_matcher_arg()
cases = [
NEA('should match',
expected=matcher_assertions.is_matching_success(),
actual=lines_content([
'1st line',
'2nd line',
])
),
NEA('should not match',
expected=matcher_assertions.is_arbitrary_matching_failure(),
actual='a single line'
),
]
for case in cases:
source = single_line_source(
src('{string_matcher_type} {defined_name} = {matcher_argument}',
defined_name=defined_name,
matcher_argument=not_num_lines_eq_1_matcher_arg),
)
expectation = Expectation(
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,
),
assertion_on_instruction_environment=
AssertApplicationOfMatcherInSymbolTable(defined_name,
actual_model_contents=case.actual,
expected_matcher_result=case.expected),
)
with self.subTest(case.name):
# ACT & ASSERT #
self._check(source, ArrangementWithSds(), expectation)
def test_assignment_of_program_without_arguments(self):
python_source = 'exit(72)'
resolver_of_referred_program = program_resolvers.for_py_source_on_command_line(python_source)
name_of_defined_symbol = 'the_symbol'
referred_symbol = NameAndValue(
'PRE_EXISTING_PROGRAM_SYMBOL',
resolver_of_referred_program
)
symbols = SymbolTable({
referred_symbol.name:
symbol_utils.container(referred_symbol.value)
})
program = pgm_args.symbol_ref_command_line(sym_ref_args.sym_ref_cmd_line(
referred_symbol.name))
source = multi_line_source('{program_type} {defined_symbol} = {program}',
['following line'],
defined_symbol=name_of_defined_symbol,
program=program)
expected_symbol_container = asrt_rs.matches_container(
assertion_on_resolver=asrt_resolver.matches_resolver_of_program(
references=asrt.matches_sequence([
is_program_reference_to(referred_symbol.name)
]),
resolved_program_value=asrt_dir_dep_val.matches_multi_dir_dependent_value(
DirDependencies.NONE,
lambda tcds: matches_py_source_on_cmd_line_program(python_source)),
symbols=symbols
))
expectation = Expectation(
source=asrt_source.is_at_beginning_of_line(2),
symbol_usages=asrt.matches_sequence([
asrt_sym_usage.matches_definition(
name=asrt.equals(name_of_defined_symbol),
container=expected_symbol_container)
]),
symbols_after_main=assert_symbol_table_is_singleton(
expected_name=name_of_defined_symbol,
value_assertion=expected_symbol_container,
)
)
self._check(source, ArrangementWithSds(), expectation)
def test_successful_parse_of_reference(self):
defined_name = 'defined_name'
referenced_symbol = NameAndValue('referenced_name',
ARBITRARY_RESOLVER)
symbols = SymbolTable({
referenced_symbol.name:
symbol_utils.container(referenced_symbol.value)
})
# ARRANGE #
source = single_line_source(
src('{string_matcher_type} {defined_name} = {matcher_argument}',
defined_name=defined_name,
matcher_argument=referenced_symbol.name),
)
arrangement = ArrangementWithSds()
# EXPECTATION #
expected_container = matches_container(
matches_string_matcher_resolver(
references=asrt.matches_sequence([
is_reference_to_string_matcher(referenced_symbol.name)
]),
symbols=symbols)
)
expectation = Expectation(
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 #
self._check(source, arrangement, expectation)
def check_matcher_should_be_parsed_as_full_expression(put: unittest.TestCase,
symbol_1: MatcherTypeSymbolContext,
symbol_2: MatcherTypeSymbolContext,
value_type: ValueType,
):
# ARRANGE #
symbols = [symbol_1, symbol_2]
value_argument = matcher_argument.disjunction([symbol_1.argument, symbol_2.argument])
defined_name = 'the_defined_name'
source = remaining_source(
src3(value_type,
defined_name,
value_argument.as_str,
),
)
# EXPECTATION #
expected_symbol_references = SymbolContext.references_assertion_of_contexts(symbols)
expected_container = matches_container(
asrt.equals(value_type),
type_sdv_assertions.matches_sdv_of_file_matcher(
references=expected_symbol_references,
primitive_value=asrt.anything_goes(),
symbols=SymbolContext.symbol_table_of_contexts(symbols)
)
)
expected_symbol_usages = asrt.matches_singleton_sequence(
asrt_sym_usage.matches_definition(asrt.equals(defined_name), expected_container)
)
expected_source = asrt_source.source_is_at_end
# ACT #
actual = sut.PARTS_PARSER.parse(ARBITRARY_FS_LOCATION_INFO, source)
# ASSERT #
expected_source.apply_with_message(put, source, 'source')
expected_symbol_usages.apply_with_message(put, actual.symbol_usages, 'symbol usages')
class TestSuccessfulScenarios(unittest.TestCase):
def test_successful_parse_of_arbitrary_matcher(self):
defined_name = 'defined_name'
# ARRANGE #
argument_cases = [
NameAndValue('value on same line',
'{matcher_argument}'
),
NameAndValue('value on following line',
'{new_line} {matcher_argument}'
),
]
for case in argument_cases:
with self.subTest(case.name):
source = single_line_source(
src2(ValueType.FILES_MATCHER, defined_name, case.value,
matcher_argument=arg_syntax.arbitrary_single_line_value_that_must_not_be_quoted()),
)
# EXPECTATION #
expected_container = matches_container(
asrt.equals(ValueType.FILES_MATCHER),
type_sdv_assertions.matches_sdv_of_files_matcher()
)
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 runTest(self):
python_source = 'exit(72)'
name_of_defined_symbol = 'the_symbol'
referred_symbol = ProgramSymbolContext.of_sdv(
'PRE_EXISTING_PROGRAM_SYMBOL',
program_sdvs.for_py_source_on_command_line(python_source))
symbols = referred_symbol.symbol_table
program_abs_stx = ProgramOfSymbolReferenceAbsStx(referred_symbol.name)
define_symbol_syntax = DefineSymbolWMandatoryValue(
name_of_defined_symbol,
ValueType.PROGRAM,
program_abs_stx,
)
expected_symbol_container = matches_container(
asrt.equals(ValueType.PROGRAM),
sdv=type_sdv_assertions.matches_sdv_of_program_constant(
references=asrt.matches_sequence(
[referred_symbol.reference_assertion]),
primitive_value=matches_py_source_on_cmd_line_program(
python_source),
symbols=symbols))
expectation = MultiSourceExpectation.phase_agnostic(
symbol_usages=asrt.matches_sequence([
asrt_sym_usage.matches_definition(
name=asrt.equals(name_of_defined_symbol),
container=expected_symbol_container)
]),
symbols_after_main=assert_symbol_table_is_singleton(
expected_name=name_of_defined_symbol,
value_assertion=expected_symbol_container,
))
INSTRUCTION_CHECKER.check__abs_stx__layout_and_source_variants(
self,
define_symbol_syntax,
Arrangement.phase_agnostic(),
expectation,
)
def test_successful_parse(self):
name_pattern = 'the name pattern'
cases = [
('empty RHS SHOULD give selection of all files',
'',
file_matchers.FileMatcherConstant(True),
),
('name pattern in RHS SHOULD give selection of name pattern',
file_matcher_arguments(name_pattern=name_pattern),
file_matchers.FileMatcherNameGlobPattern(name_pattern),
),
('file type in RHS SHOULD give selection of name pattern',
file_matcher_arguments(type_match=FileType.REGULAR),
file_matchers.FileMatcherType(FileType.REGULAR),
),
]
# ARRANGE #
defined_name = 'defined_name'
for name, rhs_source, expected_file_matcher in cases:
with self.subTest(name=name):
source = single_line_source(
src('{file_matcher_type} {defined_name} = {selector_argument}',
defined_name=defined_name,
selector_argument=rhs_source),
)
expected_container = matches_container(
resolved_value_equals_file_matcher(expected_file_matcher)
)
expectation = Expectation(
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 #
self._check(source, ArrangementWithSds(), expectation)
def test_successful_parse_and_application_of_non_trivial_matcher(self):
defined_name = 'defined_name'
expected_container = matches_container(
asrt.equals(ValueType.STRING_MATCHER),
matches_sdv_of_string_matcher())
not_num_lines_eq_1_matcher_arg = self._not_num_lines_eq_1_matcher_arg()
cases = [
NEA('should match',
expected=matcher_assertions.is_matching_success(),
actual=lines_content([
'1st line',
'2nd line',
])),
NEA('should not match',
expected=matcher_assertions.is_arbitrary_matching_failure(),
actual='a single line'),
]
for case in cases:
source = single_line_source(
src2(ValueType.STRING_MATCHER, defined_name,
not_num_lines_eq_1_matcher_arg), )
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,
),
instruction_environment=AssertApplicationOfMatcherInSymbolTable(
self,
defined_name,
actual_model_contents=case.actual,
expected_matcher_result=case.expected),
)
with self.subTest(case.name):
def _expect_definition_of(
defined_name: str,
symbols_for_evaluation: SymbolTable,
references: Assertion[Sequence[SymbolReference]],
expected_contents: str,
may_depend_on_external_resources: bool,
) -> Expectation[None]:
sdv_expectation = type_sdv_assertions.matches_sdv(
asrt.is_instance(StringSourceSdv),
references=references,
symbols=symbols_for_evaluation,
resolved_value=asrt.anything_goes(),
custom=asrt.is_instance_with(
StringSourceSdv,
str_src_check.execution_assertion(
intgr_arr_exp.Arrangement(
symbols=symbols_for_evaluation,
tcds=TcdsArrangement(),
),
primitive=str_src_check.primitive__const(
asrt_string_source.pre_post_freeze__matches_str__const(
expected_contents,
may_depend_on_external_resources=may_depend_on_external_resources
)
)
)
)
)
expected_container = matches_container(
asrt.equals(ValueType.STRING_SOURCE),
sdv_expectation,
)
return 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,
)
)
def _expect_definition_of(
defined_name: str,
symbols_for_evaluation: SymbolTable,
model: FileSystemElements,
references: Assertion[Sequence[SymbolReference]],
expected_output: Assertion[pathlib.Path],
) -> Expectation[pathlib.Path]:
sdv_expectation = type_sdv_assertions.matches_sdv(
asrt.is_instance(FilesSourceSdv),
references=references,
symbols=symbols_for_evaluation,
resolved_value=asrt.anything_goes(),
custom=asrt.is_instance_with(
FilesSourceSdv,
file_src_check.execution_assertion(
model,
intgr_arr_exp.Arrangement(
symbols=symbols_for_evaluation,
tcds=TcdsArrangement(),
),
ExecutionExpectation(
main_result=expected_output,
)
),
)
)
expected_container = matches_container(
asrt.equals(ValueType.FILES_SOURCE),
sdv_expectation,
)
return 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,
)
)
def test_successful_parse_of_reference(self):
defined_name = 'defined_name'
referenced_symbol = FilesMatcherSymbolContext.of_arbitrary_value('referenced_name')
symbols = referenced_symbol.symbol_table
# ARRANGE #
source = single_line_source(
src2(ValueType.FILES_MATCHER, defined_name, referenced_symbol.name),
)
arrangement = Arrangement.phase_agnostic()
# EXPECTATION #
expected_container = matches_container(
asrt.equals(ValueType.FILES_MATCHER),
type_sdv_assertions.matches_sdv_of_files_matcher(
references=asrt.matches_sequence([
referenced_symbol.reference_assertion
]),
symbols=symbols)
)
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, expectation)
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 test_successful_parse_of_regex(self):
# ARRANGE #
regex_str = 'the_regex'
models_for_equivalence_check = [
asrt_matcher.ModelInfo((1, regex_str)),
asrt_matcher.ModelInfo((2, 'before' + regex_str + 'after')),
asrt_matcher.ModelInfo((1, 'no match')),
]
symbol = LineMatcherSymbolContext.of_sdv('the_symbol_name',
CONSTANT_TRUE_MATCHER_SDV)
regex_matcher_syntax = argument_syntax.syntax_for_regex_matcher(
regex_str)
matcher_argument = argument_syntax.syntax_for_and([
symbol.name,
regex_matcher_syntax,
])
defined_name = 'defined_name'
argument_cases = [
NameAndValue('value on same line', '{matcher_argument}'),
NameAndValue('value on following line',
'{new_line} {matcher_argument}'),
]
for argument_case in argument_cases:
with self.subTest(argument_case.name):
source = remaining_source(
src2(ValueType.LINE_MATCHER,
defined_name,
argument_case.value,
matcher_argument=matcher_argument),
following_lines=['following line'],
)
# EXPECTATION #
symbol_table = symbol.symbol_table
expected_matcher_sdv = parse_line_matcher.parsers().full.parse(
remaining_source(matcher_argument))
expected_matcher = resolving_helper(
symbol_table).resolve_matcher(expected_matcher_sdv)
expected_container = matches_container(
asrt.equals(ValueType.LINE_MATCHER),
sdv=type_sdv_assertions.matches_sdv_of_line_matcher(
references=asrt.matches_sequence([
is_reference_to_line_matcher(symbol.name),
]),
primitive_value=asrt_matcher.is_equivalent_to(
expected_matcher, models_for_equivalence_check),
symbols=symbol_table,
))
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 test_successful_parse_of_sequence(self):
# ARRANGE #
regex_str = 'the_regex'
replacement_str = 'the_replacement'
symbol = StringTransformerSymbolContext.of_primitive(
'the_symbol_name',
string_transformers.must_not_be_used()
)
replace_transformer_syntax = argument_syntax.syntax_for_replace_transformer(regex_str,
replacement_str)
defined_name = 'defined_name'
cases = [
SourceCase('Expression on single line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER,
defined_name,
argument_syntax.syntax_for_sequence_of_transformers([
symbol.name,
replace_transformer_syntax,
])),
following_lines=['following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(2)
),
SourceCase('Expression on following line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{new_line} {transformer_argument}',
transformer_argument=argument_syntax.syntax_for_sequence_of_transformers([
symbol.name,
replace_transformer_syntax,
])),
following_lines=['following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(3)
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}',
the_symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax],
),
source_assertion=asrt_source.source_is_at_end
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line, non-exr on 3rd line',
source=
remaining_source(
src2(ValueType.STRING_TRANSFORMER, defined_name, '{the_symbol_name} {sequence_operator}',
the_symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax,
'following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(3)
),
]
# EXPECTATION #
expected_container = matches_container(
asrt.equals(ValueType.STRING_TRANSFORMER),
sdv=matches_sdv_of_string_transformer_constant(
references=asrt.matches_sequence([
is_reference_to_string_transformer(symbol.name),
]),
primitive_value=asrt_string_transformer.is_identity_transformer(False),
symbols=symbol.symbol_table,
)
)
for source_case in cases:
with self.subTest(source_case.name):
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,
),
source=source_case.source_assertion
)
# ACT & ASSERT #
INSTRUCTION_CHECKER.check(self, source_case.source, Arrangement.phase_agnostic(), expectation)
def assert_matches_definition_of_sdv(self) -> Assertion[SymbolDefinition]:
return matches_definition(
name=asrt.equals(self.name),
container=self.value.assert_matches_container_of_sdv)
def test_successful_parse_of_sequence(self):
# ARRANGE #
regex_str = 'the_regex'
replacement_str = 'the_replacement'
symbol = NameAndValue('the_symbol_name',
transformers.CustomStringTransformerTestImpl())
replace_transformer_syntax = argument_syntax.syntax_for_replace_transformer(regex_str,
replacement_str)
defined_name = 'defined_name'
cases = [
SourceCase('Expression on single line',
source=
remaining_source(
src('{lines_trans_type} {defined_name} = {transformer_argument}',
defined_name=defined_name,
transformer_argument=argument_syntax.syntax_for_sequence_of_transformers([
symbol.name,
replace_transformer_syntax,
])),
following_lines=['following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(2)
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line',
source=
remaining_source(
src('{lines_trans_type} {defined_name} = {symbol_name} {sequence_operator}',
defined_name=defined_name,
symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax],
),
source_assertion=asrt_source.source_is_at_end
),
SourceCase('1st expr on first line followed by operator, 2nd expr on next line, non-exr on 3rd line',
source=
remaining_source(
src('{lines_trans_type} {defined_name} = {symbol_name} {sequence_operator}',
defined_name=defined_name,
symbol_name=symbol.name,
sequence_operator=SEQUENCE_OPERATOR_NAME),
following_lines=[replace_transformer_syntax,
'following line'],
),
source_assertion=asrt_source.is_at_beginning_of_line(3)
),
]
# EXPECTATION #
the_sequence_transformer = SequenceStringTransformer([
symbol.value,
transformers.replace_transformer(regex_str,
replacement_str),
])
expected_container = matches_container(
assertion_on_resolver=
resolved_value_equals_string_transformer(
the_sequence_transformer,
references=asrt.matches_sequence([
is_reference_to_string_transformer(symbol.name),
]),
symbols=SymbolTable({
symbol.name: container(StringTransformerConstant(symbol.value)),
}),
)
)
for source_case in cases:
with self.subTest(source_case.name):
expectation = Expectation(
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,
),
source=source_case.source_assertion
)
# ACT & ASSERT #
self._check(source_case.source, ArrangementWithSds(), expectation)